Bug 511330 - [core.genmodel.fsm] introduce simplified generator model

for state machines

* manually merged newfsmgen to newfsmgen_finalize because no rebase was
possible due to structural changes
* rebased on master
* switch to Oxygen and Xtend 2.12

Change-Id: If9a8c7421f07fb8e8fa824b7bc6761b9142b7eaf

401 files changed, 62113 insertions, 25689 deletions

diff --git a/features/org.eclipse.etrice.tests.feature/feature.xml b/features/org.eclipse.etrice.tests.feature/feature.xml
index 80e0a9f0c..6adcc594a 100644
--- a/features/org.eclipse.etrice.tests.feature/feature.xml
+++ b/features/org.eclipse.etrice.tests.feature/feature.xml
@@ -164,4 +164,12 @@ http://www.eclipse.org/legal/epl-v10.html
          version="0.0.0"
          unpack="false"/>
 
+   <plugin
+         id="org.eclipse.etrice.core.genmodel.fsm.tests"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+
 </feature>
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..252e1bf66 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,9 +234,13 @@ 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),
@@ -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/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..2c4eebbb2 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,26 @@ 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 +61,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());
+	private void addStartingPoints(Graph graph, ActiveRules localRules) {
+		List<Link> links = graph.getLinks();
+		for (Link link : links)
+			if (link.getTransition() instanceof InitialTransition) {
+				StateGraphNode cur = link.getTarget().getStateGraphNode();
+				List<HandledMessage> msgList = codeAnalyzer.analyze(link.getTransition().getAction());
 				if (cur instanceof State) {
 					msgList.addAll(codeAnalyzer.analyze(((State) cur).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 +114,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 +147,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 +164,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 +186,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 +217,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 +234,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/xtend-gen/org/eclipse/etrice/core/common/validation/ValidationHelpers.java b/plugins/org.eclipse.etrice.core.common/xtend-gen/org/eclipse/etrice/core/common/validation/ValidationHelpers.java
new file mode 100644
index 000000000..7510e4031
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.common/xtend-gen/org/eclipse/etrice/core/common/validation/ValidationHelpers.java
@@ -0,0 +1,136 @@
+/**
+ * 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:
+ * 		hrentz (initial contribution)
+ */
+package org.eclipse.etrice.core.common.validation;
+
+import com.google.common.base.Function;
+import com.google.common.base.Objects;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtend.lib.Property;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.Pure;
+
+/**
+ * @author hrentz
+ */
+@SuppressWarnings("all")
+public class ValidationHelpers {
+  public static class NamedObject {
+    @Property
+    private String _name;
+    
+    @Property
+    private EObject _obj;
+    
+    @Property
+    private EStructuralFeature _feature;
+    
+    public NamedObject(final String name, final EObject obj, final EStructuralFeature feature) {
+      this.setName(name);
+      this.setObj(obj);
+      this.setFeature(feature);
+    }
+    
+    @Pure
+    public String getName() {
+      return this._name;
+    }
+    
+    public void setName(final String name) {
+      this._name = name;
+    }
+    
+    @Pure
+    public EObject getObj() {
+      return this._obj;
+    }
+    
+    public void setObj(final EObject obj) {
+      this._obj = obj;
+    }
+    
+    @Pure
+    public EStructuralFeature getFeature() {
+      return this._feature;
+    }
+    
+    public void setFeature(final EStructuralFeature feature) {
+      this._feature = feature;
+    }
+  }
+  
+  public static class NamedObjectList extends ArrayList<ValidationHelpers.NamedObject> {
+    public void addAll(final List<? extends EObject> items, final EStructuralFeature feature) {
+      final Consumer<EObject> _function = (EObject it) -> {
+        Object _eGet = it.eGet(feature);
+        ValidationHelpers.NamedObject _namedObject = new ValidationHelpers.NamedObject(((String) _eGet), it, feature);
+        this.add(_namedObject);
+      };
+      items.forEach(_function);
+    }
+  }
+  
+  public static Iterable<ValidationHelpers.NamedObject> removeUniques(final List<ValidationHelpers.NamedObject> items) {
+    Iterable<ValidationHelpers.NamedObject> _xblockexpression = null;
+    {
+      final Set<String> allOfName = CollectionLiterals.<String>newHashSet();
+      final Set<String> duplicateNames = CollectionLiterals.<String>newHashSet();
+      for (final ValidationHelpers.NamedObject i : items) {
+        String _name = i.getName();
+        boolean _contains = allOfName.contains(_name);
+        if (_contains) {
+          String _name_1 = i.getName();
+          duplicateNames.add(_name_1);
+        } else {
+          String _name_2 = i.getName();
+          allOfName.add(_name_2);
+        }
+      }
+      final Function1<ValidationHelpers.NamedObject, Boolean> _function = (ValidationHelpers.NamedObject i_1) -> {
+        String _name_3 = i_1.getName();
+        return Boolean.valueOf(duplicateNames.contains(_name_3));
+      };
+      _xblockexpression = IterableExtensions.<ValidationHelpers.NamedObject>filter(items, _function);
+    }
+    return _xblockexpression;
+  }
+  
+  public static Iterable<ValidationHelpers.NamedObject> inSameResource(final Iterable<ValidationHelpers.NamedObject> items, final Resource resource) {
+    final Function1<ValidationHelpers.NamedObject, Boolean> _function = (ValidationHelpers.NamedObject i) -> {
+      EObject _obj = i.getObj();
+      Resource _eResource = _obj.eResource();
+      return Boolean.valueOf(Objects.equal(_eResource, resource));
+    };
+    return IterableExtensions.<ValidationHelpers.NamedObject>filter(items, _function);
+  }
+  
+  /**
+   * Visitor for inheritance, safeguards from null, eProxy and circular issues.
+   * 
+   * @param start EObject, may be null
+   * @param function return null to exit
+   */
+  public static <E extends EObject> void saveRecursiveVisitor(final E start, final Function<E, E> function) {
+    final Set<E> visited = CollectionLiterals.<E>newHashSet();
+    E next = start;
+    while ((((!Objects.equal(next, null)) && (!next.eIsProxy())) && visited.add(next))) {
+      E _apply = function.apply(next);
+      next = _apply;
+    }
+  }
+}
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.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/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/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/xtend-gen/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.java b/plugins/org.eclipse.etrice.core.fsm/xtend-gen/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.java
new file mode 100644
index 000000000..c2e739c5d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.fsm/xtend-gen/org/eclipse/etrice/core/fsm/postprocessing/ImplPostprocessor.java
@@ -0,0 +1,82 @@
+/**
+ * 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
+ */
+package org.eclipse.etrice.core.fsm.postprocessing;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EcorePackage;
+import org.eclipse.etrice.core.common.postprocessing.PostprocessingHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.GeneratedMetamodel;
+
+@SuppressWarnings("all")
+public class ImplPostprocessor {
+  public boolean process(final GeneratedMetamodel metamodel) {
+    boolean _xblockexpression = false;
+    {
+      final EPackage fsmPackage = metamodel.getEPackage();
+      final EClass state = PostprocessingHelpers.getClass(fsmPackage, "State");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("return (this instanceof <%org.eclipse.etrice.core.fsm.fSM.SimpleState%>)? ((SimpleState)this).getName() :(this instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedState%>)? (((RefinedState)this).getTarget()==null? \"\":((RefinedState)this).getTarget().getName()) :\"\";");
+      PostprocessingHelpers.addOperation(state, "getName", EcorePackage.Literals.ESTRING, Integer.valueOf(1), _builder.toString());
+      final EClass stateGraphItem = PostprocessingHelpers.getClass(fsmPackage, "StateGraphItem");
+      EClassifier _eClassifier = EcorePackage.eINSTANCE.getEClassifier("EString");
+      StringConcatenation _builder_1 = new StringConcatenation();
+      _builder_1.append("if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.State%>) ");
+      _builder_1.newLine();
+      _builder_1.append("\t");
+      _builder_1.append("return ((State)this).getName();");
+      _builder_1.newLine();
+      _builder_1.append("else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.TrPoint%>)");
+      _builder_1.newLine();
+      _builder_1.append("\t");
+      _builder_1.append("return ((TrPoint)this).getName();");
+      _builder_1.newLine();
+      _builder_1.append("else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.ChoicePoint%>)");
+      _builder_1.newLine();
+      _builder_1.append("\t");
+      _builder_1.append("return ((ChoicePoint)this).getName();");
+      _builder_1.newLine();
+      _builder_1.append("else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.Transition%>)");
+      _builder_1.newLine();
+      _builder_1.append("\t");
+      _builder_1.append("return ((Transition)this).getName();");
+      _builder_1.newLine();
+      _builder_1.append("else if (this instanceof <%org.eclipse.etrice.core.fsm.fSM.RefinedTransition%>)");
+      _builder_1.newLine();
+      _builder_1.append("\t");
+      _builder_1.append("return ((RefinedTransition)this).getTarget().getName();");
+      _builder_1.newLine();
+      _builder_1.append("return \"\";");
+      _builder_1.newLine();
+      PostprocessingHelpers.addOperation(stateGraphItem, "getName", _eClassifier, Integer.valueOf(1), _builder_1.toString());
+      final EClass ifItem = PostprocessingHelpers.getClass(fsmPackage, "AbstractInterfaceItem");
+      EClassifier _eClassifier_1 = EcorePackage.eINSTANCE.getEClassifier("EString");
+      StringConcatenation _builder_2 = new StringConcatenation();
+      _builder_2.append("return getName();");
+      _builder_2.newLine();
+      PostprocessingHelpers.addOperation(ifItem, "getDisplayName", _eClassifier_1, Integer.valueOf(1), _builder_2.toString());
+      PostprocessingHelpers.addOperation(ifItem, "getSemantics", fsmPackage.getEClassifier("ProtocolSemantics"));
+      PostprocessingHelpers.addOperation(ifItem, "getAllIncomingAbstractMessages", EcorePackage.Literals.EOBJECT, Integer.valueOf((-1)), null);
+      PostprocessingHelpers.addOperation(ifItem, "getAllOutgoingAbstractMessages", EcorePackage.Literals.EOBJECT, Integer.valueOf((-1)), null);
+      PostprocessingHelpers.addOperation(ifItem, "isEventDriven", EcorePackage.Literals.EBOOLEAN, Integer.valueOf(1), "return true;");
+      final EClass itemOwner = PostprocessingHelpers.addClass(fsmPackage, "IInterfaceItemOwner");
+      itemOwner.setAbstract(true);
+      itemOwner.setInterface(true);
+      PostprocessingHelpers.addOperation(itemOwner, "getAbstractInterfaceItems", fsmPackage.getEClassifier("AbstractInterfaceItem"), Integer.valueOf((-1)), null);
+      PostprocessingHelpers.addOperation(itemOwner, "getAllAbstractInterfaceItems", fsmPackage.getEClassifier("AbstractInterfaceItem"), Integer.valueOf((-1)), null);
+      final EClass comp = PostprocessingHelpers.getClass(fsmPackage, "ModelComponent");
+      _xblockexpression = comp.getESuperTypes().add(itemOwner);
+    }
+    return _xblockexpression;
+  }
+}
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/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.etrice.core.genmodel.fsm/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..f42de363a
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.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.7
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.7
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 d1390cfed..15d2e4e6f 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,16 @@ Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.etrice.core.genmodel.fsm;singleton:=true
 Bundle-Version: 1.1.1.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.1";visibility:=reexport,
  org.eclipse.core.runtime,
  org.eclipse.emf.ecore;visibility:=reexport,
  org.eclipse.emf.ecore.xmi;visibility:=reexport
 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.properties b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties
index 857b8ceb4..9e7a79cd1 100644
--- a/plugins/org.eclipse.etrice.core.genmodel.fsm/build.properties
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/build.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)
-#  
+#
 
 bin.includes = .,\
                model/,\
@@ -14,5 +6,7 @@ bin.includes = .,\
                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..ec8b74c5b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/src/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.xtend
@@ -0,0 +1,239 @@
+/*******************************************************************************
+ * 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, IDiagnostician validator) {
+		super()
+		injector.injectMembers(this)
+		this.validator = 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..ba6fd869a
--- /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.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.java
new file mode 100644
index 000000000..f277d3950
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/BasicFsmGenBuilder.java
@@ -0,0 +1,323 @@
+/**
+ * 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.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+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.TrPoint;
+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;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@SuppressWarnings("all")
+public class BasicFsmGenBuilder {
+  @Inject
+  @Extension
+  protected FSMHelpers fsmHelpers;
+  
+  protected final FsmGenFactory factory = FsmGenFactory.eINSTANCE;
+  
+  private int inheritanceLevel = 0;
+  
+  public BasicFsmGenBuilder(final Injector injector) {
+    injector.injectMembers(this);
+  }
+  
+  protected BasicFsmGenBuilder() {
+  }
+  
+  public GraphContainer createTransformedModel(final ModelComponent mc) {
+    return this.createContainer(mc);
+  }
+  
+  private GraphContainer createContainer(final ModelComponent mc) {
+    final ArrayList<?> _cacheKey = CollectionLiterals.newArrayList(mc);
+    final GraphContainer _result;
+    synchronized (_createCache_createContainer) {
+      if (_createCache_createContainer.containsKey(_cacheKey)) {
+        return _createCache_createContainer.get(_cacheKey);
+      }
+      GraphContainer _createGraphContainer = this.factory.createGraphContainer();
+      _result = _createGraphContainer;
+      _createCache_createContainer.put(_cacheKey, _result);
+    }
+    _init_createContainer(_result, mc);
+    return _result;
+  }
+  
+  private final HashMap<ArrayList<?>, GraphContainer> _createCache_createContainer = CollectionLiterals.newHashMap();
+  
+  private void _init_createContainer(final GraphContainer it, final ModelComponent mc) {
+    it.setComponent(mc);
+    it.setGraph(this.createStateMachine(mc));
+  }
+  
+  private Graph createStateMachine(final ModelComponent mc) {
+    Graph _xblockexpression = null;
+    {
+      final StateGraph superFSM = this.fsmHelpers.getSuperStateMachine(mc);
+      Graph _xifexpression = null;
+      if ((superFSM != null)) {
+        Graph _xblockexpression_1 = null;
+        {
+          final Graph baseGraph = this.createStateMachine(this.fsmHelpers.getModelComponent(superFSM));
+          this.inheritanceLevel++;
+          _xblockexpression_1 = this.mergeGraph(baseGraph, this.fsmHelpers.getActualStateMachine(mc));
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        Graph _xifexpression_1 = null;
+        StateGraph _actualStateMachine = this.fsmHelpers.getActualStateMachine(mc);
+        boolean _tripleNotEquals = (_actualStateMachine != null);
+        if (_tripleNotEquals) {
+          StateGraph _actualStateMachine_1 = this.fsmHelpers.getActualStateMachine(mc);
+          Graph _createGraph = null;
+          if (_actualStateMachine_1!=null) {
+            _createGraph=this.createGraph(_actualStateMachine_1);
+          }
+          _xifexpression_1 = _createGraph;
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  private Graph mergeGraph(final Graph graph, final StateGraph sg) {
+    final Consumer<Node> _function = new Consumer<Node>() {
+      @Override
+      public void accept(final Node it) {
+        it.setInherited(true);
+      }
+    };
+    graph.getNodes().forEach(_function);
+    final Consumer<Link> _function_1 = new Consumer<Link>() {
+      @Override
+      public void accept(final Link it) {
+        it.setInherited(true);
+      }
+    };
+    graph.getLinks().forEach(_function_1);
+    this.createContents(graph, sg);
+    graph.setStateGraph(sg);
+    return graph;
+  }
+  
+  private Graph createGraph(final StateGraph sg) {
+    final ArrayList<?> _cacheKey = CollectionLiterals.newArrayList(sg);
+    final Graph _result;
+    synchronized (_createCache_createGraph) {
+      if (_createCache_createGraph.containsKey(_cacheKey)) {
+        return _createCache_createGraph.get(_cacheKey);
+      }
+      Graph _createGraph = this.factory.createGraph();
+      _result = _createGraph;
+      _createCache_createGraph.put(_cacheKey, _result);
+    }
+    _init_createGraph(_result, sg);
+    return _result;
+  }
+  
+  private final HashMap<ArrayList<?>, Graph> _createCache_createGraph = CollectionLiterals.newHashMap();
+  
+  private void _init_createGraph(final Graph it, final StateGraph sg) {
+    it.setStateGraph(sg);
+    this.createContents(it, sg);
+  }
+  
+  private void createContents(final Graph graph, final StateGraph sg) {
+    final Function1<ChoicePoint, Node> _function = new Function1<ChoicePoint, Node>() {
+      @Override
+      public Node apply(final ChoicePoint it) {
+        return BasicFsmGenBuilder.this.createNode(it);
+      }
+    };
+    graph.getNodes().addAll(ListExtensions.<ChoicePoint, Node>map(sg.getChPoints(), _function));
+    final Function1<TrPoint, Node> _function_1 = new Function1<TrPoint, Node>() {
+      @Override
+      public Node apply(final TrPoint it) {
+        return BasicFsmGenBuilder.this.createNode(it);
+      }
+    };
+    graph.getNodes().addAll(ListExtensions.<TrPoint, Node>map(sg.getTrPoints(), _function_1));
+    final Function1<SimpleState, Node> _function_2 = new Function1<SimpleState, Node>() {
+      @Override
+      public Node apply(final SimpleState it) {
+        return BasicFsmGenBuilder.this.createNode(it);
+      }
+    };
+    Iterables.<Node>addAll(graph.getNodes(), IterableExtensions.<SimpleState, Node>map(Iterables.<SimpleState>filter(sg.getStates(), SimpleState.class), _function_2));
+    final Function1<Transition, Link> _function_3 = new Function1<Transition, Link>() {
+      @Override
+      public Link apply(final Transition it) {
+        return BasicFsmGenBuilder.this.createLink(it);
+      }
+    };
+    graph.getLinks().addAll(ListExtensions.<Transition, Link>map(sg.getTransitions(), _function_3));
+    final Consumer<RefinedState> _function_4 = new Consumer<RefinedState>() {
+      @Override
+      public void accept(final RefinedState it) {
+        BasicFsmGenBuilder.this.handleRefinedState(it);
+      }
+    };
+    Iterables.<RefinedState>filter(sg.getStates(), RefinedState.class).forEach(_function_4);
+    final Consumer<RefinedTransition> _function_5 = new Consumer<RefinedTransition>() {
+      @Override
+      public void accept(final RefinedTransition it) {
+        BasicFsmGenBuilder.this.handleRefinedTransition(it);
+      }
+    };
+    sg.getRefinedTransitions().forEach(_function_5);
+  }
+  
+  private void handleRefinedState(final RefinedState s) {
+    final Node refinedNode = this.createNode(this.fsmHelpers.getFinalTarget(s));
+    StateGraph _subgraph = s.getSubgraph();
+    boolean _tripleNotEquals = (_subgraph != null);
+    if (_tripleNotEquals) {
+      Graph _subgraph_1 = refinedNode.getSubgraph();
+      boolean _tripleNotEquals_1 = (_subgraph_1 != null);
+      if (_tripleNotEquals_1) {
+        this.mergeGraph(refinedNode.getSubgraph(), s.getSubgraph());
+      } else {
+        refinedNode.setSubgraph(this.createGraph(s.getSubgraph()));
+      }
+    }
+    final Node target = refinedNode;
+    target.setStateGraphNode(s);
+  }
+  
+  private void handleRefinedTransition(final RefinedTransition t) {
+    Link _createLink = this.createLink(t.getTarget());
+    _createLink.setTransition(t);
+  }
+  
+  private Link createLink(final Transition tr) {
+    final ArrayList<?> _cacheKey = CollectionLiterals.newArrayList(tr);
+    final Link _result;
+    synchronized (_createCache_createLink) {
+      if (_createCache_createLink.containsKey(_cacheKey)) {
+        return _createCache_createLink.get(_cacheKey);
+      }
+      Link _createLink = this.factory.createLink();
+      _result = _createLink;
+      _createCache_createLink.put(_cacheKey, _result);
+    }
+    _init_createLink(_result, tr);
+    return _result;
+  }
+  
+  private final HashMap<ArrayList<?>, Link> _createCache_createLink = CollectionLiterals.newHashMap();
+  
+  private void _init_createLink(final Link it, final Transition tr) {
+    it.setTransition(tr);
+    Node _xifexpression = null;
+    if ((tr instanceof NonInitialTransition)) {
+      _xifexpression = this.createNode(((NonInitialTransition)tr).getFrom());
+    }
+    it.setSource(_xifexpression);
+    it.setTarget(this.createNode(tr.getTo()));
+  }
+  
+  private Node _createNode(final StateGraphNode s) {
+    final ArrayList<?> _cacheKey = CollectionLiterals.newArrayList(s);
+    final Node _result;
+    synchronized (_createCache_createNode) {
+      if (_createCache_createNode.containsKey(_cacheKey)) {
+        return _createCache_createNode.get(_cacheKey);
+      }
+      Node _createNode = this.factory.createNode();
+      _result = _createNode;
+      _createCache_createNode.put(_cacheKey, _result);
+    }
+    _init_createNode(_result, s);
+    return _result;
+  }
+  
+  private final HashMap<ArrayList<?>, Node> _createCache_createNode = CollectionLiterals.newHashMap();
+  
+  private void _init_createNode(final Node it, final StateGraphNode s) {
+    it.setStateGraphNode(s);
+    it.setInheritanceLevel(this.inheritanceLevel);
+    Graph _xifexpression = null;
+    if ((s instanceof State)) {
+      StateGraph _subgraph = ((State)s).getSubgraph();
+      Graph _createGraph = null;
+      if (_subgraph!=null) {
+        _createGraph=this.createGraph(_subgraph);
+      }
+      _xifexpression = _createGraph;
+    }
+    it.setSubgraph(_xifexpression);
+  }
+  
+  private Node _createNode(final ChoicepointTerminal tt) {
+    return this.createNode(tt.getCp());
+  }
+  
+  private Node _createNode(final TrPointTerminal tt) {
+    return this.createNode(tt.getTrPoint());
+  }
+  
+  private Node _createNode(final StateTerminal tt) {
+    return this.createNode(tt.getState());
+  }
+  
+  private Node _createNode(final SubStateTrPointTerminal tt) {
+    return this.createNode(tt.getTrPoint());
+  }
+  
+  private Node createNode(final EObject tt) {
+    if (tt instanceof ChoicepointTerminal) {
+      return _createNode((ChoicepointTerminal)tt);
+    } else if (tt instanceof StateGraphNode) {
+      return _createNode((StateGraphNode)tt);
+    } else if (tt instanceof StateTerminal) {
+      return _createNode((StateTerminal)tt);
+    } else if (tt instanceof SubStateTrPointTerminal) {
+      return _createNode((SubStateTrPointTerminal)tt);
+    } else if (tt instanceof TrPointTerminal) {
+      return _createNode((TrPointTerminal)tt);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(tt).toString());
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.java
new file mode 100644
index 000000000..a1b424ebd
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/ExtendedFsmGenBuilder.java
@@ -0,0 +1,291 @@
+/**
+ * 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.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+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.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+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.BasicFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+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.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;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class ExtendedFsmGenBuilder extends BasicFsmGenBuilder {
+  @Inject
+  @Extension
+  protected ICommonDataCalculator _iCommonDataCalculator;
+  
+  @Inject
+  @Extension
+  protected TriggerExtensions _triggerExtensions;
+  
+  protected IDiagnostician validator;
+  
+  private final FsmGenFactory factory = FsmGenFactory.eINSTANCE;
+  
+  public ExtendedFsmGenBuilder(final Injector injector, final IDiagnostician validator) {
+    super();
+    injector.injectMembers(this);
+    this.validator = validator;
+  }
+  
+  /**
+   * computes the available triggers for all leaf states
+   */
+  public GraphContainer withTriggersInStates(final GraphContainer gc) {
+    boolean _isInitializedTriggersInStates = gc.isInitializedTriggersInStates();
+    boolean _not = (!_isInitializedTriggersInStates);
+    if (_not) {
+      Graph _graph = gc.getGraph();
+      boolean _tripleNotEquals = (_graph != null);
+      if (_tripleNotEquals) {
+        final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+          @Override
+          public Boolean apply(final Node it) {
+            Graph _subgraph = it.getSubgraph();
+            return Boolean.valueOf((_subgraph == null));
+          }
+        };
+        final Procedure1<Node> _function_1 = new Procedure1<Node>() {
+          @Override
+          public void apply(final Node it) {
+            ExtendedFsmGenBuilder.this.computeTriggers(it);
+          }
+        };
+        IteratorExtensions.<Node>forEach(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(gc.getGraph()), _function), _function_1);
+      }
+      gc.setInitializedTriggersInStates(true);
+    }
+    return gc;
+  }
+  
+  /**
+   * determines all transition chain heads of all transitions
+   */
+  public GraphContainer withChainHeads(final GraphContainer gc) {
+    boolean _isInitializedChainHeads = gc.isInitializedChainHeads();
+    boolean _not = (!_isInitializedChainHeads);
+    if (_not) {
+      Graph _graph = gc.getGraph();
+      boolean _tripleNotEquals = (_graph != null);
+      if (_tripleNotEquals) {
+        final Procedure1<Link> _function = new Procedure1<Link>() {
+          @Override
+          public void apply(final Link it) {
+            ExtendedFsmGenBuilder.this.followChain(it, it);
+          }
+        };
+        IteratorExtensions.<Link>forEach(FsmGenExtensions.getAllChainHeads(gc.getGraph()), _function);
+      }
+      gc.setInitializedChainHeads(true);
+    }
+    return gc;
+  }
+  
+  /**
+   * calculates and stores the common data. Prerequisite is the computation of the
+   * chain heads, which is performed if not done already.
+   */
+  public GraphContainer withCommonData(final GraphContainer gc) {
+    boolean _isInitializedChainHeads = gc.isInitializedChainHeads();
+    boolean _not = (!_isInitializedChainHeads);
+    if (_not) {
+      this.withChainHeads(gc);
+    }
+    boolean _isInitializedCommonData = gc.isInitializedCommonData();
+    boolean _not_1 = (!_isInitializedCommonData);
+    if (_not_1) {
+      Graph _graph = gc.getGraph();
+      boolean _tripleNotEquals = (_graph != null);
+      if (_tripleNotEquals) {
+        final Procedure1<Link> _function = new Procedure1<Link>() {
+          @Override
+          public void apply(final Link it) {
+            it.setCommonData(ExtendedFsmGenBuilder.this._iCommonDataCalculator.calculateCommonData(it));
+          }
+        };
+        IteratorExtensions.<Link>forEach(FsmGenExtensions.getAllLinks(gc.getGraph()), _function);
+      }
+      gc.setInitializedCommonData(true);
+    }
+    return gc;
+  }
+  
+  private void followChain(final Link l, final Link head) {
+    TransitionBase _transition = head.getTransition();
+    boolean _not = (!(_transition instanceof TriggeredTransition));
+    if (_not) {
+      l.setIfitemTriggered(false);
+    }
+    l.getChainHeads().add(head);
+    final StateGraphNode target = l.getTarget().getStateGraphNode();
+    if (((target instanceof State) || (target instanceof TransitionPoint))) {
+      return;
+    } else {
+      EList<Link> _outgoing = l.getTarget().getOutgoing();
+      for (final Link next : _outgoing) {
+        this.followChain(next, head);
+      }
+    }
+  }
+  
+  private void computeTriggers(final Node s) {
+    final LinkedHashMap<String, CommonTrigger> caughtTriggers = CollectionLiterals.<String, CommonTrigger>newLinkedHashMap();
+    this.computeTriggersRecursive(s, caughtTriggers);
+    s.getCaughtTriggers().clear();
+    s.getCaughtTriggers().addAll(caughtTriggers.values());
+  }
+  
+  private void computeTriggersRecursive(final Node s, final HashMap<String, CommonTrigger> caughtTriggers) {
+    this.computeTriggers(IterableExtensions.<Link>toList(FsmGenExtensions.getOutgoingTriggeredTransitionLinks(s)), caughtTriggers);
+    final Function1<Node, Iterable<Link>> _function = new Function1<Node, Iterable<Link>>() {
+      @Override
+      public Iterable<Link> apply(final Node it) {
+        return FsmGenExtensions.getOutgoingTriggeredTransitionLinks(it);
+      }
+    };
+    final List<Link> trPointTransitions = IterableExtensions.<Link>toList(Iterables.<Link>concat(IterableExtensions.<Node, Iterable<Link>>map(FsmGenExtensions.getTransitionPointNodes(s.getGraph()), _function)));
+    this.computeTriggers(trPointTransitions, caughtTriggers);
+    boolean _isTopLevel = FsmGenExtensions.isTopLevel(s.getGraph());
+    boolean _not = (!_isTopLevel);
+    if (_not) {
+      this.computeTriggersRecursive(FsmGenExtensions.getParentState(s), caughtTriggers);
+    }
+  }
+  
+  private void computeTriggers(final List<Link> sameLevelLinks, final HashMap<String, CommonTrigger> caughtTriggers) {
+    final HashMap<TransitionBase, Link> trans2link = CollectionLiterals.<TransitionBase, Link>newHashMap();
+    final Consumer<Link> _function = new Consumer<Link>() {
+      @Override
+      public void accept(final Link it) {
+        trans2link.put(it.getTransition(), it);
+      }
+    };
+    sameLevelLinks.forEach(_function);
+    for (final Link l : sameLevelLinks) {
+      TransitionBase _transition = l.getTransition();
+      EList<Trigger> _triggers = ((TriggeredTransition) _transition).getTriggers();
+      for (final Trigger tr : _triggers) {
+        {
+          final boolean triggerHasGuard = this.fsmHelpers.hasGuard(tr);
+          EList<MessageFromIf> _msgFromIfPairs = tr.getMsgFromIfPairs();
+          for (final MessageFromIf mif : _msgFromIfPairs) {
+            {
+              final String tag = this._triggerExtensions.getTriggerTag(mif);
+              CommonTrigger ct = caughtTriggers.get(tag);
+              if ((ct == null)) {
+                ct = this.createCommonTrigger(l, mif, tag);
+                ct.setHasGuard(triggerHasGuard);
+                caughtTriggers.put(tag, ct);
+              } else {
+                final Function1<Link, EList<Trigger>> _function_1 = new Function1<Link, EList<Trigger>>() {
+                  @Override
+                  public EList<Trigger> apply(final Link it) {
+                    TransitionBase _transition = it.getTransition();
+                    return ((TriggeredTransition) _transition).getTriggers();
+                  }
+                };
+                final Function1<Trigger, Boolean> _function_2 = new Function1<Trigger, Boolean>() {
+                  @Override
+                  public Boolean apply(final Trigger it) {
+                    return Boolean.valueOf((ExtendedFsmGenBuilder.this.hasMatchingTrigger(it, tag) && (!ExtendedFsmGenBuilder.this.fsmHelpers.hasGuard(it))));
+                  }
+                };
+                Trigger _head = IterableExtensions.<Trigger>head(IterableExtensions.<Trigger>filter(Iterables.<Trigger>concat(ListExtensions.<Link, EList<Trigger>>map(ct.getLinks(), _function_1)), _function_2));
+                EObject _eContainer = null;
+                if (_head!=null) {
+                  _eContainer=_head.eContainer();
+                }
+                final TriggeredTransition unguarded = ((TriggeredTransition) _eContainer);
+                if ((unguarded != null)) {
+                  final Link unguardedLink = trans2link.get(unguarded);
+                  boolean _contains = sameLevelLinks.contains(unguardedLink);
+                  if (_contains) {
+                    if (triggerHasGuard) {
+                      final int idx = ct.getLinks().indexOf(unguardedLink);
+                      ct.setHasGuard(triggerHasGuard);
+                      ct.getLinks().add(idx, l);
+                    } else {
+                      this.validationError("Transitions with same trigger on same level have to be guarded!", l.getTransition(), FSMPackage.eINSTANCE.getTriggeredTransition_Triggers());
+                    }
+                  }
+                } else {
+                  ct.getLinks().add(l);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  private boolean hasMatchingTrigger(final Trigger trig, final String tag) {
+    EList<MessageFromIf> _msgFromIfPairs = trig.getMsgFromIfPairs();
+    for (final MessageFromIf mifp2 : _msgFromIfPairs) {
+      {
+        final String tr2 = this._triggerExtensions.getTriggerTag(mifp2);
+        boolean _equals = tr2.equals(tag);
+        if (_equals) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  
+  private CommonTrigger createCommonTrigger(final Link l, final MessageFromIf mif, final String tag) {
+    final CommonTrigger it = this.factory.createCommonTrigger();
+    it.setTrigger(tag);
+    it.setIfitem(mif.getFrom());
+    it.setMsg(mif.getMessage());
+    it.getLinks().add(l);
+    return it;
+  }
+  
+  protected void validationError(final String msg, final EObject obj, final EStructuralFeature feature) {
+    this.validationError(msg, obj, feature, IDiagnostician.INSIGNIFICANT_INDEX);
+  }
+  
+  protected void validationError(final String msg, final EObject obj, final EStructuralFeature feature, final int idx) {
+    this.validator.error(msg, obj, feature, idx);
+  }
+}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.java
new file mode 100644
index 000000000..50e6b61ee
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenChecker.java
@@ -0,0 +1,194 @@
+/**
+ * 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.common.base.Objects;
+import com.google.common.collect.Iterators;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+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.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.TrPoint;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+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.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class FsmGenChecker {
+  public static void check(final GraphContainer gc, final ILogger logger) {
+    final Procedure1<Graph> _function = new Procedure1<Graph>() {
+      @Override
+      public void apply(final Graph it) {
+        FsmGenChecker.checkGraph(it, logger);
+      }
+    };
+    IteratorExtensions.<Graph>forEach(Iterators.<Graph>filter(gc.eAllContents(), Graph.class), _function);
+    final Procedure1<Node> _function_1 = new Procedure1<Node>() {
+      @Override
+      public void apply(final Node it) {
+        FsmGenChecker.checkNode(it, logger);
+      }
+    };
+    IteratorExtensions.<Node>forEach(Iterators.<Node>filter(gc.eAllContents(), Node.class), _function_1);
+    final Procedure1<Link> _function_2 = new Procedure1<Link>() {
+      @Override
+      public void apply(final Link it) {
+        FsmGenChecker.checkLink(it, logger);
+      }
+    };
+    IteratorExtensions.<Link>forEach(Iterators.<Link>filter(gc.eAllContents(), Link.class), _function_2);
+  }
+  
+  private static void checkLink(final Link it, final ILogger logger) {
+    TransitionBase _transition = it.getTransition();
+    boolean _equals = Objects.equal(_transition, null);
+    if (_equals) {
+      logger.logError("graph doesn\'t point to ROOM transition");
+    } else {
+      boolean _eIsProxy = it.getTransition().eIsProxy();
+      if (_eIsProxy) {
+        logger.logError("unresolved ROOM transition");
+      } else {
+        EObject _eContainer = it.getTransition().eContainer();
+        boolean _equals_1 = Objects.equal(_eContainer, null);
+        if (_equals_1) {
+          logger.logError("dangling ROOM transition");
+        } else {
+          Node _target = it.getTarget();
+          boolean _equals_2 = Objects.equal(_target, null);
+          if (_equals_2) {
+            logger.logError("link without target");
+          } else {
+            if ((Objects.equal(it.getSource(), null) && (it.getTransition() instanceof NonInitialTransition))) {
+              logger.logError("non-initial link without source");
+            }
+          }
+        }
+      }
+    }
+    Node _source = it.getSource();
+    boolean _notEquals = (!Objects.equal(_source, null));
+    if (_notEquals) {
+      FsmGenChecker.checkLinkEnd(it, it.getSource(), logger);
+    }
+    FsmGenChecker.checkLinkEnd(it, it.getTarget(), logger);
+  }
+  
+  private static void checkLinkEnd(final Link link, final Node node, final ILogger logger) {
+    EObject _eContainer = node.eContainer();
+    EObject _eContainer_1 = link.eContainer();
+    boolean _equals = Objects.equal(_eContainer, _eContainer_1);
+    if (_equals) {
+      return;
+    } else {
+      StateGraphNode _stateGraphNode = node.getStateGraphNode();
+      boolean _not = (!(_stateGraphNode instanceof TrPoint));
+      if (_not) {
+        logger.logError("subgraph item is not transition point");
+      } else {
+        EObject _eContainer_2 = node.eContainer().eContainer();
+        boolean _not_1 = (!(_eContainer_2 instanceof Node));
+        if (_not_1) {
+          logger.logError("subgraph item is in unexpected container");
+        } else {
+          EObject _eContainer_3 = node.eContainer().eContainer();
+          StateGraphNode _stateGraphNode_1 = ((Node) _eContainer_3).getStateGraphNode();
+          boolean _not_2 = (!(_stateGraphNode_1 instanceof State));
+          if (_not_2) {
+            logger.logError("subgraph item is in unexpected container");
+          } else {
+            EObject _eContainer_4 = node.eContainer().eContainer().eContainer();
+            EObject _eContainer_5 = link.eContainer();
+            boolean _notEquals = (!Objects.equal(_eContainer_4, _eContainer_5));
+            if (_notEquals) {
+              logger.logError("subgraph item is in unexpected container");
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  private static void checkNode(final Node it, final ILogger logger) {
+    StateGraphNode _stateGraphNode = it.getStateGraphNode();
+    boolean _equals = Objects.equal(_stateGraphNode, null);
+    if (_equals) {
+      logger.logError("graph doesn\'t point to ROOM state graph node");
+    } else {
+      boolean _eIsProxy = it.getStateGraphNode().eIsProxy();
+      if (_eIsProxy) {
+        logger.logError("unresolved ROOM graph node");
+      } else {
+        EObject _eContainer = it.getStateGraphNode().eContainer();
+        boolean _equals_1 = Objects.equal(_eContainer, null);
+        if (_equals_1) {
+          logger.logError("dangling ROOM graph node");
+        } else {
+          String _name = it.getStateGraphNode().getName();
+          boolean _equals_2 = Objects.equal(_name, null);
+          if (_equals_2) {
+            logger.logError("ROOM graph node without name");
+          } else {
+            Graph _graph = it.getGraph();
+            boolean _equals_3 = Objects.equal(_graph, null);
+            if (_equals_3) {
+              logger.logError("node isn\'t contained in a graph");
+            }
+          }
+        }
+      }
+    }
+    EList<Link> _incoming = it.getIncoming();
+    for (final Link l : _incoming) {
+      StateGraphNode _stateGraphNode_1 = l.getTarget().getStateGraphNode();
+      StateGraphNode _stateGraphNode_2 = it.getStateGraphNode();
+      boolean _notEquals = (!Objects.equal(_stateGraphNode_1, _stateGraphNode_2));
+      if (_notEquals) {
+        logger.logError("ROOM target node of an incoming transition must be myself");
+      }
+    }
+    EList<Link> _outgoing = it.getOutgoing();
+    for (final Link l_1 : _outgoing) {
+      StateGraphNode _stateGraphNode_3 = l_1.getSource().getStateGraphNode();
+      StateGraphNode _stateGraphNode_4 = it.getStateGraphNode();
+      boolean _notEquals_1 = (!Objects.equal(_stateGraphNode_3, _stateGraphNode_4));
+      if (_notEquals_1) {
+        logger.logError("ROOM source node of an outgoing transition must be myself");
+      }
+    }
+  }
+  
+  private static void checkGraph(final Graph it, final ILogger logger) {
+    StateGraph _stateGraph = it.getStateGraph();
+    boolean _equals = Objects.equal(_stateGraph, null);
+    if (_equals) {
+      logger.logError("graph doesn\'t point to ROOM state graph");
+    } else {
+      boolean _eIsProxy = it.getStateGraph().eIsProxy();
+      if (_eIsProxy) {
+        logger.logError("unresolved ROOM graph");
+      } else {
+        EObject _eContainer = it.getStateGraph().eContainer();
+        boolean _equals_1 = Objects.equal(_eContainer, null);
+        if (_equals_1) {
+          logger.logError("dangling ROOM graph");
+        }
+      }
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.java
new file mode 100644
index 000000000..76ea3c4b3
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/FsmGenExtensions.java
@@ -0,0 +1,540 @@
+/**
+ * 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.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+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.StateGraphNode;
+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.GraphItem;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@SuppressWarnings("all")
+public class FsmGenExtensions {
+  public static String _getName(final Node nd) {
+    return nd.getStateGraphNode().getName();
+  }
+  
+  public static String _getName(final Link l) {
+    return l.getTransition().getName();
+  }
+  
+  public static Iterable<Node> getStateNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof State));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllNodes(final Graph g) {
+    return Iterators.<Node>filter(g.eAllContents(), Node.class);
+  }
+  
+  public static Iterator<Node> getAllStateNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof State));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<Node> getChoicePointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof ChoicePoint));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllChoicePointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof ChoicePoint));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<Node> getTrPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof TrPoint));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllTrPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof TrPoint));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<Node> getTransitionPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof TransitionPoint));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllTransitionPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof TransitionPoint));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<Node> getEntryPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof EntryPoint));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllEntryPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof EntryPoint));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<Node> getExitPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof ExitPoint));
+      }
+    };
+    return IterableExtensions.<Node>filter(g.getNodes(), _function);
+  }
+  
+  public static Iterator<Node> getAllExitPointNodes(final Graph g) {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof ExitPoint));
+      }
+    };
+    return IteratorExtensions.<Node>filter(FsmGenExtensions.getAllNodes(g), _function);
+  }
+  
+  public static Iterable<State> getStates(final Graph g) {
+    final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() {
+      @Override
+      public StateGraphNode apply(final Node it) {
+        return it.getStateGraphNode();
+      }
+    };
+    return Iterables.<State>filter(IterableExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getStateNodes(g), _function), State.class);
+  }
+  
+  public static Iterator<State> getAllStates(final Graph g) {
+    final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() {
+      @Override
+      public StateGraphNode apply(final Node it) {
+        return it.getStateGraphNode();
+      }
+    };
+    return Iterators.<State>filter(IteratorExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getAllStateNodes(g), _function), State.class);
+  }
+  
+  public static Iterable<ChoicePoint> getChoicePoints(final Graph g) {
+    final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() {
+      @Override
+      public StateGraphNode apply(final Node it) {
+        return it.getStateGraphNode();
+      }
+    };
+    return Iterables.<ChoicePoint>filter(IterableExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getChoicePointNodes(g), _function), ChoicePoint.class);
+  }
+  
+  public static Iterable<TrPoint> getTrPoints(final Graph g) {
+    final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() {
+      @Override
+      public StateGraphNode apply(final Node it) {
+        return it.getStateGraphNode();
+      }
+    };
+    return Iterables.<TrPoint>filter(IterableExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getTrPointNodes(g), _function), TrPoint.class);
+  }
+  
+  public static InitialTransition getInitialTransition(final Graph g) {
+    final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() {
+      @Override
+      public TransitionBase apply(final Link it) {
+        return it.getTransition();
+      }
+    };
+    return IterableExtensions.<InitialTransition>head(Iterables.<InitialTransition>filter(ListExtensions.<Link, TransitionBase>map(g.getLinks(), _function), InitialTransition.class));
+  }
+  
+  public static Iterator<Link> getAllLinks(final Graph g) {
+    return Iterators.<Link>filter(g.eAllContents(), Link.class);
+  }
+  
+  public static Iterator<Link> getAllInitialTranisitionLinks(final Graph g) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof InitialTransition));
+      }
+    };
+    return IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(g), _function);
+  }
+  
+  public static Iterator<Link> getAllTriggeredTranisitionLinks(final Graph g) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof TriggeredTransition));
+      }
+    };
+    return IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(g), _function);
+  }
+  
+  public static Iterator<Link> getAllContinuationTranisitionLinks(final Graph g) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof ContinuationTransition));
+      }
+    };
+    return IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(g), _function);
+  }
+  
+  public static Iterator<Link> getAllCPBranchTranisitionLinks(final Graph g) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof CPBranchTransition));
+      }
+    };
+    return IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(g), _function);
+  }
+  
+  /**
+   * 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 Iterator<Link> getAllChainHeads(final Graph g) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        return Boolean.valueOf(FsmGenExtensions.isChainHead(it));
+      }
+    };
+    return IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(g), _function);
+  }
+  
+  /**
+   * @param l a link
+   * @return {@code true} if the transition associated with this link is a chain head
+   * 
+   * @see #isChainHead(TransitionBase))
+   */
+  public static boolean isChainHead(final Link l) {
+    return FsmGenExtensions.isChainHead(l.getTransition());
+  }
+  
+  /**
+   * 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 boolean isChainHead(final TransitionBase t) {
+    boolean _xifexpression = false;
+    if ((t instanceof RefinedTransition)) {
+      _xifexpression = FsmGenExtensions.isChainHead(((RefinedTransition)t).getTarget());
+    } else {
+      _xifexpression = (((t instanceof InitialTransition) || 
+        (t instanceof GuardedTransition)) || 
+        (t instanceof TriggeredTransition));
+    }
+    return _xifexpression;
+  }
+  
+  public static Iterable<Link> getOutgoingTriggeredTransitionLinks(final Node s) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof TriggeredTransition));
+      }
+    };
+    return IterableExtensions.<Link>filter(s.getOutgoing(), _function);
+  }
+  
+  public static Iterable<TriggeredTransition> getOutgoingTriggeredTransitions(final Node s) {
+    final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() {
+      @Override
+      public TransitionBase apply(final Link it) {
+        return it.getTransition();
+      }
+    };
+    return Iterables.<TriggeredTransition>filter(IterableExtensions.<Link, TransitionBase>map(FsmGenExtensions.getOutgoingTriggeredTransitionLinks(s), _function), TriggeredTransition.class);
+  }
+  
+  public static List<TransitionBase> getOutgoingTransitionsHierarchically(final Node s) {
+    final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() {
+      @Override
+      public TransitionBase apply(final Link it) {
+        return it.getTransition();
+      }
+    };
+    return ListExtensions.<Link, TransitionBase>map(FsmGenExtensions.getOutgoingLinksHierarchically(s), _function);
+  }
+  
+  public static ArrayList<Link> getOutgoingLinksHierarchically(final Node s) {
+    final ArrayList<Link> result = CollectionLiterals.<Link>newArrayList();
+    Node current = s;
+    while ((current != null)) {
+      {
+        result.addAll(s.getOutgoing());
+        final Function1<Node, EList<Link>> _function = new Function1<Node, EList<Link>>() {
+          @Override
+          public EList<Link> apply(final Node it) {
+            return it.getOutgoing();
+          }
+        };
+        Iterables.<Link>addAll(result, Iterables.<Link>concat(IterableExtensions.<Node, EList<Link>>map(FsmGenExtensions.getTransitionPointNodes(s.getGraph()), _function)));
+        current = FsmGenExtensions.getParentState(current);
+      }
+    }
+    return result;
+  }
+  
+  public static boolean isTopLevel(final Graph g) {
+    boolean _xifexpression = false;
+    if ((g != null)) {
+      EObject _eContainer = g.eContainer();
+      _xifexpression = (_eContainer instanceof GraphContainer);
+    } else {
+      _xifexpression = true;
+    }
+    return _xifexpression;
+  }
+  
+  public static boolean isEmpty(final Graph g) {
+    return ((g == null) || (g.getNodes().isEmpty() && g.getLinks().isEmpty()));
+  }
+  
+  public static boolean isLeaf(final Node n) {
+    Graph _subgraph = n.getSubgraph();
+    return (_subgraph == null);
+  }
+  
+  public static boolean isTopLevel(final Node n) {
+    return FsmGenExtensions.isTopLevel(n.getGraph());
+  }
+  
+  public static Node getParentState(final Node n) {
+    Node _xifexpression = null;
+    boolean _isTopLevel = FsmGenExtensions.isTopLevel(n);
+    if (_isTopLevel) {
+      _xifexpression = null;
+    } else {
+      EObject _eContainer = n.getGraph().eContainer();
+      _xifexpression = ((Node) _eContainer);
+    }
+    return _xifexpression;
+  }
+  
+  public static Link getChoicepointDefaultBranch(final Node n) {
+    StateGraphNode _stateGraphNode = n.getStateGraphNode();
+    boolean _not = (!(_stateGraphNode instanceof ChoicePoint));
+    if (_not) {
+      return null;
+    }
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof ContinuationTransition));
+      }
+    };
+    return IterableExtensions.<Link>head(IterableExtensions.<Link>filter(n.getOutgoing(), _function));
+  }
+  
+  public static Node getParentState(final Link l) {
+    Node _xifexpression = null;
+    boolean _isTopLevel = FsmGenExtensions.isTopLevel(l.getGraph());
+    if (_isTopLevel) {
+      _xifexpression = null;
+    } else {
+      EObject _eContainer = l.getGraph().eContainer();
+      _xifexpression = ((Node) _eContainer);
+    }
+    return _xifexpression;
+  }
+  
+  public static boolean isHandler(final Link l) {
+    boolean _xblockexpression = false;
+    {
+      final StateGraphNode sourceNode = l.getSource().getStateGraphNode();
+      boolean _xifexpression = false;
+      if ((sourceNode instanceof TransitionPoint)) {
+        _xifexpression = ((TransitionPoint)sourceNode).isHandler();
+      } else {
+        _xifexpression = false;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  public static List<DetailCode> getAllDetailCodes(final Graph graph) {
+    final ArrayList<DetailCode> detailCodes = CollectionLiterals.<DetailCode>newArrayList();
+    if ((graph != null)) {
+      final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() {
+        @Override
+        public TransitionBase apply(final Link it) {
+          return it.getTransition();
+        }
+      };
+      final Iterator<TransitionBase> allTransitions = IteratorExtensions.<Link, TransitionBase>map(FsmGenExtensions.getAllLinks(graph), _function);
+      final Function1<TransitionBase, DetailCode> _function_1 = new Function1<TransitionBase, DetailCode>() {
+        @Override
+        public DetailCode apply(final TransitionBase it) {
+          return it.getAction();
+        }
+      };
+      List<DetailCode> _list = IteratorExtensions.<DetailCode>toList(IteratorExtensions.<TransitionBase, DetailCode>map(allTransitions, _function_1));
+      Iterables.<DetailCode>addAll(detailCodes, _list);
+      final Function1<Node, StateGraphNode> _function_2 = new Function1<Node, StateGraphNode>() {
+        @Override
+        public StateGraphNode apply(final Node it) {
+          return it.getStateGraphNode();
+        }
+      };
+      final Iterator<State> allStates = Iterators.<State>filter(IteratorExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getAllStateNodes(graph), _function_2), State.class);
+      final Function1<State, DetailCode> _function_3 = new Function1<State, DetailCode>() {
+        @Override
+        public DetailCode apply(final State it) {
+          return it.getEntryCode();
+        }
+      };
+      List<DetailCode> _list_1 = IteratorExtensions.<DetailCode>toList(IteratorExtensions.<State, DetailCode>map(allStates, _function_3));
+      Iterables.<DetailCode>addAll(detailCodes, _list_1);
+      final Function1<State, DetailCode> _function_4 = new Function1<State, DetailCode>() {
+        @Override
+        public DetailCode apply(final State it) {
+          return it.getDoCode();
+        }
+      };
+      List<DetailCode> _list_2 = IteratorExtensions.<DetailCode>toList(IteratorExtensions.<State, DetailCode>map(allStates, _function_4));
+      Iterables.<DetailCode>addAll(detailCodes, _list_2);
+      final Function1<State, DetailCode> _function_5 = new Function1<State, DetailCode>() {
+        @Override
+        public DetailCode apply(final State it) {
+          return it.getExitCode();
+        }
+      };
+      List<DetailCode> _list_3 = IteratorExtensions.<DetailCode>toList(IteratorExtensions.<State, DetailCode>map(allStates, _function_5));
+      Iterables.<DetailCode>addAll(detailCodes, _list_3);
+    }
+    return detailCodes;
+  }
+  
+  public static Link getLinkFor(final GraphContainer gc, final TransitionBase t) {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition == t));
+      }
+    };
+    return IteratorExtensions.<Link>findFirst(FsmGenExtensions.getAllLinks(gc.getGraph()), _function);
+  }
+  
+  public static String getName(final GraphItem l) {
+    if (l instanceof Link) {
+      return _getName((Link)l);
+    } else if (l instanceof Node) {
+      return _getName((Node)l);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(l).toString());
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.java b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.java
new file mode 100644
index 000000000..dc45ccf27
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.genmodel.fsm/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/TriggerExtensions.java
@@ -0,0 +1,49 @@
+/**
+ * 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.common.base.Objects;
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
+import org.eclipse.etrice.core.fsm.fSM.Trigger;
+import org.eclipse.etrice.core.fsm.naming.FSMNameProvider;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+@SuppressWarnings("all")
+public class TriggerExtensions {
+  public static String TRIGGER_SEP = "#";
+  
+  @Inject
+  @Extension
+  protected FSMNameProvider _fSMNameProvider;
+  
+  public String getTriggerTag(final MessageFromIf it) {
+    String _name = it.getFrom().getName();
+    String _plus = (_name + TriggerExtensions.TRIGGER_SEP);
+    String _messageName = this._fSMNameProvider.getMessageName(it.getMessage());
+    return (_plus + _messageName);
+  }
+  
+  public boolean isMatching(final Trigger trig, final String trigstr) {
+    EList<MessageFromIf> _msgFromIfPairs = trig.getMsgFromIfPairs();
+    for (final MessageFromIf mif : _msgFromIfPairs) {
+      {
+        final String tr = this.getTriggerTag(mif);
+        boolean _equals = Objects.equal(tr, trigstr);
+        if (_equals) {
+          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.room.ui/src-gen/org/eclipse/etrice/core/ui/AbstractRoomUiModule.java b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/AbstractRoomUiModule.java
index 3f2d172cb..df718a6f7 100644
--- a/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/AbstractRoomUiModule.java
+++ b/plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/AbstractRoomUiModule.java
@@ -157,10 +157,5 @@ public abstract class AbstractRoomUiModule extends org.eclipse.xtext.ui.DefaultU
 		return org.eclipse.xtext.ui.compare.DefaultViewerCreator.class;
 	}
 
-	// contributed by org.eclipse.xtext.ui.generator.compare.CompareFragment
-	public void configureCompareViewerTitle(com.google.inject.Binder binder) {
-		binder.bind(String.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.UIBindings.COMPARE_VIEWER_TITLE)).toInstance("Room Compare");
-	}
-
 
 }
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..275e04cf9 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
@@ -1804,6 +1804,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 +3955,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.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..259a21d55 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:27905:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalRoom.g:27905:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalRoom.g:27858:12: ( '0x' | '0X' )
+            // InternalRoom.g:27905: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:27905:13: '0x'
                     {
                     match("0x"); 
 
@@ -2700,7 +2700,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:27858:18: '0X'
+                    // InternalRoom.g:27905: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:27905: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:27907:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalRoom.g:27907:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalRoom.g:27860:27: ( options {greedy=false; } : . )*
+            // InternalRoom.g:27907: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:27907: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:27909:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalRoom.g:27909:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalRoom.g:27862:11: ( '^' )?
+            // InternalRoom.g:27909: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:27909: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:27909: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:27911:10: ( ( '0' .. '9' )+ )
+            // InternalRoom.g:27911:12: ( '0' .. '9' )+
             {
-            // InternalRoom.g:27864:12: ( '0' .. '9' )+
+            // InternalRoom.g:27911: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:27911: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:27913:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalRoom.g:27913:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalRoom.g:27866:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:27913: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:27913:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalRoom.g:27866:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalRoom.g:27913: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:27913:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3009,7 +3009,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:27866:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalRoom.g:27913: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:27913:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalRoom.g:27866:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalRoom.g:27913: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:27913:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3061,7 +3061,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:27866:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalRoom.g:27913: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:27915:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalRoom.g:27915:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalRoom.g:27868:24: ( options {greedy=false; } : . )*
+            // InternalRoom.g:27915: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:27915: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:27917:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalRoom.g:27917:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalRoom.g:27870:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalRoom.g:27917: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:27917: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:27917: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:27917:41: ( '\\r' )? '\\n'
                     {
-                    // InternalRoom.g:27870:41: ( '\\r' )?
+                    // InternalRoom.g:27917: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:27917: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:27919:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalRoom.g:27919:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalRoom.g:27872:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:27919: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:27921:16: ( . )
+            // InternalRoom.g:27921: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..9609ea605 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
@@ -4960,12 +4960,89 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalRoom.g:1808:1: entryRuleTransitionBase : ruleTransitionBase EOF ;
+    public final void entryRuleTransitionBase() throws RecognitionException {
+        try {
+            // InternalRoom.g:1809:1: ( ruleTransitionBase EOF )
+            // InternalRoom.g:1810: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:1817:1: ruleTransitionBase : ( ( rule__TransitionBase__Alternatives ) ) ;
+    public final void ruleTransitionBase() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:1821:2: ( ( ( rule__TransitionBase__Alternatives ) ) )
+            // InternalRoom.g:1822:1: ( ( rule__TransitionBase__Alternatives ) )
+            {
+            // InternalRoom.g:1822:1: ( ( rule__TransitionBase__Alternatives ) )
+            // InternalRoom.g:1823:1: ( rule__TransitionBase__Alternatives )
+            {
+             before(grammarAccess.getTransitionBaseAccess().getAlternatives()); 
+            // InternalRoom.g:1824:1: ( rule__TransitionBase__Alternatives )
+            // InternalRoom.g:1824: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:1836: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:1837:1: ( ruleTransition EOF )
+            // InternalRoom.g:1838:1: ruleTransition EOF
             {
              before(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -4991,21 +5068,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransition"
-    // InternalRoom.g:1819:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ;
+    // InternalRoom.g:1845: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:1849:2: ( ( ( rule__Transition__Alternatives ) ) )
+            // InternalRoom.g:1850:1: ( ( rule__Transition__Alternatives ) )
             {
-            // InternalRoom.g:1824:1: ( ( rule__Transition__Alternatives ) )
-            // InternalRoom.g:1825:1: ( rule__Transition__Alternatives )
+            // InternalRoom.g:1850:1: ( ( rule__Transition__Alternatives ) )
+            // InternalRoom.g:1851:1: ( rule__Transition__Alternatives )
             {
              before(grammarAccess.getTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1826:1: ( rule__Transition__Alternatives )
-            // InternalRoom.g:1826:2: rule__Transition__Alternatives
+            // InternalRoom.g:1852:1: ( rule__Transition__Alternatives )
+            // InternalRoom.g:1852:2: rule__Transition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Transition__Alternatives();
@@ -5038,11 +5115,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalRoom.g:1838:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ;
+    // InternalRoom.g:1864: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:1865:1: ( ruleNonInitialTransition EOF )
+            // InternalRoom.g:1866:1: ruleNonInitialTransition EOF
             {
              before(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5068,21 +5145,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNonInitialTransition"
-    // InternalRoom.g:1847:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ;
+    // InternalRoom.g:1873: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:1877:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) )
+            // InternalRoom.g:1878:1: ( ( rule__NonInitialTransition__Alternatives ) )
             {
-            // InternalRoom.g:1852:1: ( ( rule__NonInitialTransition__Alternatives ) )
-            // InternalRoom.g:1853:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalRoom.g:1878:1: ( ( rule__NonInitialTransition__Alternatives ) )
+            // InternalRoom.g:1879:1: ( rule__NonInitialTransition__Alternatives )
             {
              before(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1854:1: ( rule__NonInitialTransition__Alternatives )
-            // InternalRoom.g:1854:2: rule__NonInitialTransition__Alternatives
+            // InternalRoom.g:1880:1: ( rule__NonInitialTransition__Alternatives )
+            // InternalRoom.g:1880:2: rule__NonInitialTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NonInitialTransition__Alternatives();
@@ -5115,11 +5192,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalRoom.g:1866:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ;
+    // InternalRoom.g:1892: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:1893:1: ( ruleTransitionChainStartTransition EOF )
+            // InternalRoom.g:1894:1: ruleTransitionChainStartTransition EOF
             {
              before(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5145,21 +5222,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionChainStartTransition"
-    // InternalRoom.g:1875:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ;
+    // InternalRoom.g:1901: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:1905:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) )
+            // InternalRoom.g:1906:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
             {
-            // InternalRoom.g:1880:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
-            // InternalRoom.g:1881:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalRoom.g:1906:1: ( ( rule__TransitionChainStartTransition__Alternatives ) )
+            // InternalRoom.g:1907:1: ( rule__TransitionChainStartTransition__Alternatives )
             {
              before(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); 
-            // InternalRoom.g:1882:1: ( rule__TransitionChainStartTransition__Alternatives )
-            // InternalRoom.g:1882:2: rule__TransitionChainStartTransition__Alternatives
+            // InternalRoom.g:1908:1: ( rule__TransitionChainStartTransition__Alternatives )
+            // InternalRoom.g:1908:2: rule__TransitionChainStartTransition__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionChainStartTransition__Alternatives();
@@ -5192,11 +5269,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalRoom.g:1894:1: entryRuleInitialTransition : ruleInitialTransition EOF ;
+    // InternalRoom.g:1920: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:1921:1: ( ruleInitialTransition EOF )
+            // InternalRoom.g:1922:1: ruleInitialTransition EOF
             {
              before(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5222,21 +5299,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInitialTransition"
-    // InternalRoom.g:1903:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ;
+    // InternalRoom.g:1929: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:1933:2: ( ( ( rule__InitialTransition__Group__0 ) ) )
+            // InternalRoom.g:1934:1: ( ( rule__InitialTransition__Group__0 ) )
             {
-            // InternalRoom.g:1908:1: ( ( rule__InitialTransition__Group__0 ) )
-            // InternalRoom.g:1909:1: ( rule__InitialTransition__Group__0 )
+            // InternalRoom.g:1934:1: ( ( rule__InitialTransition__Group__0 ) )
+            // InternalRoom.g:1935: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:1936:1: ( rule__InitialTransition__Group__0 )
+            // InternalRoom.g:1936:2: rule__InitialTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__0();
@@ -5269,11 +5346,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalRoom.g:1922:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ;
+    // InternalRoom.g:1948: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:1949:1: ( ruleContinuationTransition EOF )
+            // InternalRoom.g:1950:1: ruleContinuationTransition EOF
             {
              before(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5299,21 +5376,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleContinuationTransition"
-    // InternalRoom.g:1931:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ;
+    // InternalRoom.g:1957: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:1961:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) )
+            // InternalRoom.g:1962:1: ( ( rule__ContinuationTransition__Group__0 ) )
             {
-            // InternalRoom.g:1936:1: ( ( rule__ContinuationTransition__Group__0 ) )
-            // InternalRoom.g:1937:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalRoom.g:1962:1: ( ( rule__ContinuationTransition__Group__0 ) )
+            // InternalRoom.g:1963: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:1964:1: ( rule__ContinuationTransition__Group__0 )
+            // InternalRoom.g:1964:2: rule__ContinuationTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__0();
@@ -5346,11 +5423,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalRoom.g:1950:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ;
+    // InternalRoom.g:1976: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:1977:1: ( ruleTriggeredTransition EOF )
+            // InternalRoom.g:1978:1: ruleTriggeredTransition EOF
             {
              before(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5376,21 +5453,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTriggeredTransition"
-    // InternalRoom.g:1959:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ;
+    // InternalRoom.g:1985: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:1989:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) )
+            // InternalRoom.g:1990:1: ( ( rule__TriggeredTransition__Group__0 ) )
             {
-            // InternalRoom.g:1964:1: ( ( rule__TriggeredTransition__Group__0 ) )
-            // InternalRoom.g:1965:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalRoom.g:1990:1: ( ( rule__TriggeredTransition__Group__0 ) )
+            // InternalRoom.g:1991: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:1992:1: ( rule__TriggeredTransition__Group__0 )
+            // InternalRoom.g:1992:2: rule__TriggeredTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__0();
@@ -5423,11 +5500,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalRoom.g:1978:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ;
+    // InternalRoom.g:2004: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:2005:1: ( ruleGuardedTransition EOF )
+            // InternalRoom.g:2006:1: ruleGuardedTransition EOF
             {
              before(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5453,21 +5530,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuardedTransition"
-    // InternalRoom.g:1987:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ;
+    // InternalRoom.g:2013: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:2017:2: ( ( ( rule__GuardedTransition__Group__0 ) ) )
+            // InternalRoom.g:2018:1: ( ( rule__GuardedTransition__Group__0 ) )
             {
-            // InternalRoom.g:1992:1: ( ( rule__GuardedTransition__Group__0 ) )
-            // InternalRoom.g:1993:1: ( rule__GuardedTransition__Group__0 )
+            // InternalRoom.g:2018:1: ( ( rule__GuardedTransition__Group__0 ) )
+            // InternalRoom.g:2019: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:2020:1: ( rule__GuardedTransition__Group__0 )
+            // InternalRoom.g:2020:2: rule__GuardedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__0();
@@ -5500,11 +5577,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalRoom.g:2006:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ;
+    // InternalRoom.g:2032: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:2033:1: ( ruleCPBranchTransition EOF )
+            // InternalRoom.g:2034:1: ruleCPBranchTransition EOF
             {
              before(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5530,21 +5607,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCPBranchTransition"
-    // InternalRoom.g:2015:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ;
+    // InternalRoom.g:2041: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:2045:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) )
+            // InternalRoom.g:2046:1: ( ( rule__CPBranchTransition__Group__0 ) )
             {
-            // InternalRoom.g:2020:1: ( ( rule__CPBranchTransition__Group__0 ) )
-            // InternalRoom.g:2021:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalRoom.g:2046:1: ( ( rule__CPBranchTransition__Group__0 ) )
+            // InternalRoom.g:2047: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:2048:1: ( rule__CPBranchTransition__Group__0 )
+            // InternalRoom.g:2048:2: rule__CPBranchTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__0();
@@ -5577,11 +5654,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalRoom.g:2034:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ;
+    // InternalRoom.g:2060: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:2061:1: ( ruleRefinedTransition EOF )
+            // InternalRoom.g:2062:1: ruleRefinedTransition EOF
             {
              before(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -5607,21 +5684,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRefinedTransition"
-    // InternalRoom.g:2043:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ;
+    // InternalRoom.g:2069: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:2073:2: ( ( ( rule__RefinedTransition__Group__0 ) ) )
+            // InternalRoom.g:2074:1: ( ( rule__RefinedTransition__Group__0 ) )
             {
-            // InternalRoom.g:2048:1: ( ( rule__RefinedTransition__Group__0 ) )
-            // InternalRoom.g:2049:1: ( rule__RefinedTransition__Group__0 )
+            // InternalRoom.g:2074:1: ( ( rule__RefinedTransition__Group__0 ) )
+            // InternalRoom.g:2075: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:2076:1: ( rule__RefinedTransition__Group__0 )
+            // InternalRoom.g:2076:2: rule__RefinedTransition__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__0();
@@ -5654,11 +5731,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalRoom.g:2062:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ;
+    // InternalRoom.g:2088: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:2089:1: ( ruleTransitionTerminal EOF )
+            // InternalRoom.g:2090:1: ruleTransitionTerminal EOF
             {
              before(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5684,21 +5761,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTransitionTerminal"
-    // InternalRoom.g:2071:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ;
+    // InternalRoom.g:2097: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:2101:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) )
+            // InternalRoom.g:2102:1: ( ( rule__TransitionTerminal__Alternatives ) )
             {
-            // InternalRoom.g:2076:1: ( ( rule__TransitionTerminal__Alternatives ) )
-            // InternalRoom.g:2077:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalRoom.g:2102:1: ( ( rule__TransitionTerminal__Alternatives ) )
+            // InternalRoom.g:2103:1: ( rule__TransitionTerminal__Alternatives )
             {
              before(grammarAccess.getTransitionTerminalAccess().getAlternatives()); 
-            // InternalRoom.g:2078:1: ( rule__TransitionTerminal__Alternatives )
-            // InternalRoom.g:2078:2: rule__TransitionTerminal__Alternatives
+            // InternalRoom.g:2104:1: ( rule__TransitionTerminal__Alternatives )
+            // InternalRoom.g:2104:2: rule__TransitionTerminal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__TransitionTerminal__Alternatives();
@@ -5731,11 +5808,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalRoom.g:2090:1: entryRuleStateTerminal : ruleStateTerminal EOF ;
+    // InternalRoom.g:2116: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:2117:1: ( ruleStateTerminal EOF )
+            // InternalRoom.g:2118:1: ruleStateTerminal EOF
             {
              before(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5761,21 +5838,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalRoom.g:2099:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ;
+    // InternalRoom.g:2125: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:2129:2: ( ( ( rule__StateTerminal__StateAssignment ) ) )
+            // InternalRoom.g:2130:1: ( ( rule__StateTerminal__StateAssignment ) )
             {
-            // InternalRoom.g:2104:1: ( ( rule__StateTerminal__StateAssignment ) )
-            // InternalRoom.g:2105:1: ( rule__StateTerminal__StateAssignment )
+            // InternalRoom.g:2130:1: ( ( rule__StateTerminal__StateAssignment ) )
+            // InternalRoom.g:2131:1: ( rule__StateTerminal__StateAssignment )
             {
              before(grammarAccess.getStateTerminalAccess().getStateAssignment()); 
-            // InternalRoom.g:2106:1: ( rule__StateTerminal__StateAssignment )
-            // InternalRoom.g:2106:2: rule__StateTerminal__StateAssignment
+            // InternalRoom.g:2132:1: ( rule__StateTerminal__StateAssignment )
+            // InternalRoom.g:2132:2: rule__StateTerminal__StateAssignment
             {
             pushFollow(FOLLOW_2);
             rule__StateTerminal__StateAssignment();
@@ -5808,11 +5885,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalRoom.g:2118:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ;
+    // InternalRoom.g:2144: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:2145:1: ( ruleTrPointTerminal EOF )
+            // InternalRoom.g:2146:1: ruleTrPointTerminal EOF
             {
              before(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5838,21 +5915,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrPointTerminal"
-    // InternalRoom.g:2127:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2153: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:2157:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2158:1: ( ( rule__TrPointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2132:1: ( ( rule__TrPointTerminal__Group__0 ) )
-            // InternalRoom.g:2133:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalRoom.g:2158:1: ( ( rule__TrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2159: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:2160:1: ( rule__TrPointTerminal__Group__0 )
+            // InternalRoom.g:2160:2: rule__TrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__0();
@@ -5885,11 +5962,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalRoom.g:2146:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ;
+    // InternalRoom.g:2172: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:2173:1: ( ruleSubStateTrPointTerminal EOF )
+            // InternalRoom.g:2174:1: ruleSubStateTrPointTerminal EOF
             {
              before(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5915,21 +5992,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSubStateTrPointTerminal"
-    // InternalRoom.g:2155:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2181: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:2185:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2186:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2160:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
-            // InternalRoom.g:2161:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalRoom.g:2186:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) )
+            // InternalRoom.g:2187: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:2188:1: ( rule__SubStateTrPointTerminal__Group__0 )
+            // InternalRoom.g:2188:2: rule__SubStateTrPointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__0();
@@ -5962,11 +6039,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalRoom.g:2174:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ;
+    // InternalRoom.g:2200: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:2201:1: ( ruleChoicepointTerminal EOF )
+            // InternalRoom.g:2202:1: ruleChoicepointTerminal EOF
             {
              before(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -5992,21 +6069,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleChoicepointTerminal"
-    // InternalRoom.g:2183:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ;
+    // InternalRoom.g:2209: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:2213:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) )
+            // InternalRoom.g:2214:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
             {
-            // InternalRoom.g:2188:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
-            // InternalRoom.g:2189:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalRoom.g:2214:1: ( ( rule__ChoicepointTerminal__Group__0 ) )
+            // InternalRoom.g:2215: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:2216:1: ( rule__ChoicepointTerminal__Group__0 )
+            // InternalRoom.g:2216:2: rule__ChoicepointTerminal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__0();
@@ -6039,11 +6116,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalRoom.g:2202:1: entryRuleTrigger : ruleTrigger EOF ;
+    // InternalRoom.g:2228: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:2229:1: ( ruleTrigger EOF )
+            // InternalRoom.g:2230:1: ruleTrigger EOF
             {
              before(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -6069,21 +6146,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleTrigger"
-    // InternalRoom.g:2211:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ;
+    // InternalRoom.g:2237: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:2241:2: ( ( ( rule__Trigger__Group__0 ) ) )
+            // InternalRoom.g:2242:1: ( ( rule__Trigger__Group__0 ) )
             {
-            // InternalRoom.g:2216:1: ( ( rule__Trigger__Group__0 ) )
-            // InternalRoom.g:2217:1: ( rule__Trigger__Group__0 )
+            // InternalRoom.g:2242:1: ( ( rule__Trigger__Group__0 ) )
+            // InternalRoom.g:2243: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:2244:1: ( rule__Trigger__Group__0 )
+            // InternalRoom.g:2244:2: rule__Trigger__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__0();
@@ -6116,11 +6193,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalRoom.g:2230:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ;
+    // InternalRoom.g:2256: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:2257:1: ( ruleMessageFromIf EOF )
+            // InternalRoom.g:2258:1: ruleMessageFromIf EOF
             {
              before(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -6146,21 +6223,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleMessageFromIf"
-    // InternalRoom.g:2239:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ;
+    // InternalRoom.g:2265: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:2269:2: ( ( ( rule__MessageFromIf__Group__0 ) ) )
+            // InternalRoom.g:2270:1: ( ( rule__MessageFromIf__Group__0 ) )
             {
-            // InternalRoom.g:2244:1: ( ( rule__MessageFromIf__Group__0 ) )
-            // InternalRoom.g:2245:1: ( rule__MessageFromIf__Group__0 )
+            // InternalRoom.g:2270:1: ( ( rule__MessageFromIf__Group__0 ) )
+            // InternalRoom.g:2271: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:2272:1: ( rule__MessageFromIf__Group__0 )
+            // InternalRoom.g:2272:2: rule__MessageFromIf__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__0();
@@ -6193,11 +6270,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalRoom.g:2258:1: entryRuleGuard : ruleGuard EOF ;
+    // InternalRoom.g:2284: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:2285:1: ( ruleGuard EOF )
+            // InternalRoom.g:2286:1: ruleGuard EOF
             {
              before(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -6223,21 +6300,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleGuard"
-    // InternalRoom.g:2267:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ;
+    // InternalRoom.g:2293: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:2297:2: ( ( ( rule__Guard__Group__0 ) ) )
+            // InternalRoom.g:2298:1: ( ( rule__Guard__Group__0 ) )
             {
-            // InternalRoom.g:2272:1: ( ( rule__Guard__Group__0 ) )
-            // InternalRoom.g:2273:1: ( rule__Guard__Group__0 )
+            // InternalRoom.g:2298:1: ( ( rule__Guard__Group__0 ) )
+            // InternalRoom.g:2299: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:2300:1: ( rule__Guard__Group__0 )
+            // InternalRoom.g:2300:2: rule__Guard__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__0();
@@ -6270,11 +6347,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleProtocolSemantics"
-    // InternalRoom.g:2286:1: entryRuleProtocolSemantics : ruleProtocolSemantics EOF ;
+    // InternalRoom.g:2312: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:2313:1: ( ruleProtocolSemantics EOF )
+            // InternalRoom.g:2314:1: ruleProtocolSemantics EOF
             {
              before(grammarAccess.getProtocolSemanticsRule()); 
             pushFollow(FOLLOW_1);
@@ -6300,21 +6377,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleProtocolSemantics"
-    // InternalRoom.g:2295:1: ruleProtocolSemantics : ( ( rule__ProtocolSemantics__Group__0 ) ) ;
+    // InternalRoom.g:2321: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:2325:2: ( ( ( rule__ProtocolSemantics__Group__0 ) ) )
+            // InternalRoom.g:2326:1: ( ( rule__ProtocolSemantics__Group__0 ) )
             {
-            // InternalRoom.g:2300:1: ( ( rule__ProtocolSemantics__Group__0 ) )
-            // InternalRoom.g:2301:1: ( rule__ProtocolSemantics__Group__0 )
+            // InternalRoom.g:2326:1: ( ( rule__ProtocolSemantics__Group__0 ) )
+            // InternalRoom.g:2327: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:2328:1: ( rule__ProtocolSemantics__Group__0 )
+            // InternalRoom.g:2328:2: rule__ProtocolSemantics__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolSemantics__Group__0();
@@ -6347,11 +6424,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalRoom.g:2314:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ;
+    // InternalRoom.g:2340: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:2341:1: ( ruleSemanticsRule EOF )
+            // InternalRoom.g:2342:1: ruleSemanticsRule EOF
             {
              before(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6377,21 +6454,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSemanticsRule"
-    // InternalRoom.g:2323:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ;
+    // InternalRoom.g:2349: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:2353:2: ( ( ( rule__SemanticsRule__Alternatives ) ) )
+            // InternalRoom.g:2354:1: ( ( rule__SemanticsRule__Alternatives ) )
             {
-            // InternalRoom.g:2328:1: ( ( rule__SemanticsRule__Alternatives ) )
-            // InternalRoom.g:2329:1: ( rule__SemanticsRule__Alternatives )
+            // InternalRoom.g:2354:1: ( ( rule__SemanticsRule__Alternatives ) )
+            // InternalRoom.g:2355:1: ( rule__SemanticsRule__Alternatives )
             {
              before(grammarAccess.getSemanticsRuleAccess().getAlternatives()); 
-            // InternalRoom.g:2330:1: ( rule__SemanticsRule__Alternatives )
-            // InternalRoom.g:2330:2: rule__SemanticsRule__Alternatives
+            // InternalRoom.g:2356:1: ( rule__SemanticsRule__Alternatives )
+            // InternalRoom.g:2356:2: rule__SemanticsRule__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__SemanticsRule__Alternatives();
@@ -6424,11 +6501,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalRoom.g:2342:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ;
+    // InternalRoom.g:2368: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:2369:1: ( ruleInSemanticsRule EOF )
+            // InternalRoom.g:2370:1: ruleInSemanticsRule EOF
             {
              before(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6454,21 +6531,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInSemanticsRule"
-    // InternalRoom.g:2351:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ;
+    // InternalRoom.g:2377: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:2381:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) )
+            // InternalRoom.g:2382:1: ( ( rule__InSemanticsRule__Group__0 ) )
             {
-            // InternalRoom.g:2356:1: ( ( rule__InSemanticsRule__Group__0 ) )
-            // InternalRoom.g:2357:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalRoom.g:2382:1: ( ( rule__InSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2383: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:2384:1: ( rule__InSemanticsRule__Group__0 )
+            // InternalRoom.g:2384:2: rule__InSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__0();
@@ -6501,11 +6578,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalRoom.g:2370:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ;
+    // InternalRoom.g:2396: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:2397:1: ( ruleOutSemanticsRule EOF )
+            // InternalRoom.g:2398:1: ruleOutSemanticsRule EOF
             {
              before(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -6531,21 +6608,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleOutSemanticsRule"
-    // InternalRoom.g:2379:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ;
+    // InternalRoom.g:2405: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:2409:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) )
+            // InternalRoom.g:2410:1: ( ( rule__OutSemanticsRule__Group__0 ) )
             {
-            // InternalRoom.g:2384:1: ( ( rule__OutSemanticsRule__Group__0 ) )
-            // InternalRoom.g:2385:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalRoom.g:2410:1: ( ( rule__OutSemanticsRule__Group__0 ) )
+            // InternalRoom.g:2411: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:2412:1: ( rule__OutSemanticsRule__Group__0 )
+            // InternalRoom.g:2412:2: rule__OutSemanticsRule__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__0();
@@ -6578,11 +6655,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotation"
-    // InternalRoom.g:2398:1: entryRuleAnnotation : ruleAnnotation EOF ;
+    // InternalRoom.g:2424: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:2425:1: ( ruleAnnotation EOF )
+            // InternalRoom.g:2426:1: ruleAnnotation EOF
             {
              before(grammarAccess.getAnnotationRule()); 
             pushFollow(FOLLOW_1);
@@ -6608,21 +6685,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotation"
-    // InternalRoom.g:2407:1: ruleAnnotation : ( ( rule__Annotation__Group__0 ) ) ;
+    // InternalRoom.g:2433: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:2437:2: ( ( ( rule__Annotation__Group__0 ) ) )
+            // InternalRoom.g:2438:1: ( ( rule__Annotation__Group__0 ) )
             {
-            // InternalRoom.g:2412:1: ( ( rule__Annotation__Group__0 ) )
-            // InternalRoom.g:2413:1: ( rule__Annotation__Group__0 )
+            // InternalRoom.g:2438:1: ( ( rule__Annotation__Group__0 ) )
+            // InternalRoom.g:2439: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:2440:1: ( rule__Annotation__Group__0 )
+            // InternalRoom.g:2440:2: rule__Annotation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group__0();
@@ -6655,11 +6732,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalRoom.g:2426:1: entryRuleKeyValue : ruleKeyValue EOF ;
+    // InternalRoom.g:2452: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:2453:1: ( ruleKeyValue EOF )
+            // InternalRoom.g:2454:1: ruleKeyValue EOF
             {
              before(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -6685,21 +6762,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleKeyValue"
-    // InternalRoom.g:2435:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ;
+    // InternalRoom.g:2461: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:2465:2: ( ( ( rule__KeyValue__Group__0 ) ) )
+            // InternalRoom.g:2466:1: ( ( rule__KeyValue__Group__0 ) )
             {
-            // InternalRoom.g:2440:1: ( ( rule__KeyValue__Group__0 ) )
-            // InternalRoom.g:2441:1: ( rule__KeyValue__Group__0 )
+            // InternalRoom.g:2466:1: ( ( rule__KeyValue__Group__0 ) )
+            // InternalRoom.g:2467: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:2468:1: ( rule__KeyValue__Group__0 )
+            // InternalRoom.g:2468:2: rule__KeyValue__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__0();
@@ -6732,11 +6809,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationType"
-    // InternalRoom.g:2454:1: entryRuleAnnotationType : ruleAnnotationType EOF ;
+    // InternalRoom.g:2480: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:2481:1: ( ruleAnnotationType EOF )
+            // InternalRoom.g:2482:1: ruleAnnotationType EOF
             {
              before(grammarAccess.getAnnotationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -6762,21 +6839,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationType"
-    // InternalRoom.g:2463:1: ruleAnnotationType : ( ( rule__AnnotationType__Group__0 ) ) ;
+    // InternalRoom.g:2489: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:2493:2: ( ( ( rule__AnnotationType__Group__0 ) ) )
+            // InternalRoom.g:2494:1: ( ( rule__AnnotationType__Group__0 ) )
             {
-            // InternalRoom.g:2468:1: ( ( rule__AnnotationType__Group__0 ) )
-            // InternalRoom.g:2469:1: ( rule__AnnotationType__Group__0 )
+            // InternalRoom.g:2494:1: ( ( rule__AnnotationType__Group__0 ) )
+            // InternalRoom.g:2495: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:2496:1: ( rule__AnnotationType__Group__0 )
+            // InternalRoom.g:2496:2: rule__AnnotationType__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group__0();
@@ -6809,11 +6886,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalRoom.g:2482:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ;
+    // InternalRoom.g:2508: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:2509:1: ( ruleAnnotationAttribute EOF )
+            // InternalRoom.g:2510:1: ruleAnnotationAttribute EOF
             {
              before(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6839,21 +6916,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleAnnotationAttribute"
-    // InternalRoom.g:2491:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ;
+    // InternalRoom.g:2517: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:2521:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) )
+            // InternalRoom.g:2522:1: ( ( rule__AnnotationAttribute__Alternatives ) )
             {
-            // InternalRoom.g:2496:1: ( ( rule__AnnotationAttribute__Alternatives ) )
-            // InternalRoom.g:2497:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalRoom.g:2522:1: ( ( rule__AnnotationAttribute__Alternatives ) )
+            // InternalRoom.g:2523:1: ( rule__AnnotationAttribute__Alternatives )
             {
              before(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); 
-            // InternalRoom.g:2498:1: ( rule__AnnotationAttribute__Alternatives )
-            // InternalRoom.g:2498:2: rule__AnnotationAttribute__Alternatives
+            // InternalRoom.g:2524:1: ( rule__AnnotationAttribute__Alternatives )
+            // InternalRoom.g:2524:2: rule__AnnotationAttribute__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationAttribute__Alternatives();
@@ -6886,11 +6963,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalRoom.g:2510:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ;
+    // InternalRoom.g:2536: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:2537:1: ( ruleSimpleAnnotationAttribute EOF )
+            // InternalRoom.g:2538:1: ruleSimpleAnnotationAttribute EOF
             {
              before(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6916,21 +6993,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleSimpleAnnotationAttribute"
-    // InternalRoom.g:2519:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ;
+    // InternalRoom.g:2545: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:2549:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) )
+            // InternalRoom.g:2550:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
             {
-            // InternalRoom.g:2524:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
-            // InternalRoom.g:2525:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2550:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2551: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:2552:1: ( rule__SimpleAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2552:2: rule__SimpleAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__0();
@@ -6963,11 +7040,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalRoom.g:2538:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ;
+    // InternalRoom.g:2564: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:2565:1: ( ruleEnumAnnotationAttribute EOF )
+            // InternalRoom.g:2566:1: ruleEnumAnnotationAttribute EOF
             {
              before(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -6993,21 +7070,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleEnumAnnotationAttribute"
-    // InternalRoom.g:2547:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ;
+    // InternalRoom.g:2573: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:2577:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) )
+            // InternalRoom.g:2578:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
             {
-            // InternalRoom.g:2552:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
-            // InternalRoom.g:2553:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2578:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) )
+            // InternalRoom.g:2579: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:2580:1: ( rule__EnumAnnotationAttribute__Group__0 )
+            // InternalRoom.g:2580:2: rule__EnumAnnotationAttribute__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__0();
@@ -7040,11 +7117,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleImport"
-    // InternalRoom.g:2566:1: entryRuleImport : ruleImport EOF ;
+    // InternalRoom.g:2592: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:2593:1: ( ruleImport EOF )
+            // InternalRoom.g:2594:1: ruleImport EOF
             {
              before(grammarAccess.getImportRule()); 
             pushFollow(FOLLOW_1);
@@ -7070,21 +7147,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleImport"
-    // InternalRoom.g:2575:1: ruleImport : ( ( rule__Import__Group__0 ) ) ;
+    // InternalRoom.g:2601: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:2605:2: ( ( ( rule__Import__Group__0 ) ) )
+            // InternalRoom.g:2606:1: ( ( rule__Import__Group__0 ) )
             {
-            // InternalRoom.g:2580:1: ( ( rule__Import__Group__0 ) )
-            // InternalRoom.g:2581:1: ( rule__Import__Group__0 )
+            // InternalRoom.g:2606:1: ( ( rule__Import__Group__0 ) )
+            // InternalRoom.g:2607: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:2608:1: ( rule__Import__Group__0 )
+            // InternalRoom.g:2608:2: rule__Import__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group__0();
@@ -7117,11 +7194,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalRoom.g:2594:1: entryRuleImportedFQN : ruleImportedFQN EOF ;
+    // InternalRoom.g:2620: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:2621:1: ( ruleImportedFQN EOF )
+            // InternalRoom.g:2622:1: ruleImportedFQN EOF
             {
              before(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -7147,21 +7224,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleImportedFQN"
-    // InternalRoom.g:2603:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ;
+    // InternalRoom.g:2629: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:2633:2: ( ( ( rule__ImportedFQN__Group__0 ) ) )
+            // InternalRoom.g:2634:1: ( ( rule__ImportedFQN__Group__0 ) )
             {
-            // InternalRoom.g:2608:1: ( ( rule__ImportedFQN__Group__0 ) )
-            // InternalRoom.g:2609:1: ( rule__ImportedFQN__Group__0 )
+            // InternalRoom.g:2634:1: ( ( rule__ImportedFQN__Group__0 ) )
+            // InternalRoom.g:2635: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:2636:1: ( rule__ImportedFQN__Group__0 )
+            // InternalRoom.g:2636:2: rule__ImportedFQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__0();
@@ -7194,11 +7271,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalRoom.g:2622:1: entryRuleDocumentation : ruleDocumentation EOF ;
+    // InternalRoom.g:2648: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:2649:1: ( ruleDocumentation EOF )
+            // InternalRoom.g:2650:1: ruleDocumentation EOF
             {
              before(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -7224,21 +7301,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDocumentation"
-    // InternalRoom.g:2631:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ;
+    // InternalRoom.g:2657: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:2661:2: ( ( ( rule__Documentation__Group__0 ) ) )
+            // InternalRoom.g:2662:1: ( ( rule__Documentation__Group__0 ) )
             {
-            // InternalRoom.g:2636:1: ( ( rule__Documentation__Group__0 ) )
-            // InternalRoom.g:2637:1: ( rule__Documentation__Group__0 )
+            // InternalRoom.g:2662:1: ( ( rule__Documentation__Group__0 ) )
+            // InternalRoom.g:2663: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:2664:1: ( rule__Documentation__Group__0 )
+            // InternalRoom.g:2664:2: rule__Documentation__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__0();
@@ -7271,11 +7348,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalRoom.g:2654:1: entryRuleLiteral : ruleLiteral EOF ;
+    // InternalRoom.g:2680: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:2681:1: ( ruleLiteral EOF )
+            // InternalRoom.g:2682:1: ruleLiteral EOF
             {
              before(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7301,21 +7378,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteral"
-    // InternalRoom.g:2663:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
+    // InternalRoom.g:2689: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:2693:2: ( ( ( rule__Literal__Alternatives ) ) )
+            // InternalRoom.g:2694:1: ( ( rule__Literal__Alternatives ) )
             {
-            // InternalRoom.g:2668:1: ( ( rule__Literal__Alternatives ) )
-            // InternalRoom.g:2669:1: ( rule__Literal__Alternatives )
+            // InternalRoom.g:2694:1: ( ( rule__Literal__Alternatives ) )
+            // InternalRoom.g:2695:1: ( rule__Literal__Alternatives )
             {
              before(grammarAccess.getLiteralAccess().getAlternatives()); 
-            // InternalRoom.g:2670:1: ( rule__Literal__Alternatives )
-            // InternalRoom.g:2670:2: rule__Literal__Alternatives
+            // InternalRoom.g:2696:1: ( rule__Literal__Alternatives )
+            // InternalRoom.g:2696:2: rule__Literal__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Literal__Alternatives();
@@ -7348,11 +7425,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalRoom.g:2682:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ;
+    // InternalRoom.g:2708: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:2709:1: ( ruleBooleanLiteral EOF )
+            // InternalRoom.g:2710:1: ruleBooleanLiteral EOF
             {
              before(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7378,21 +7455,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleBooleanLiteral"
-    // InternalRoom.g:2691:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2717: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:2721:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) )
+            // InternalRoom.g:2722:1: ( ( rule__BooleanLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2696:1: ( ( rule__BooleanLiteral__Group__0 ) )
-            // InternalRoom.g:2697:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalRoom.g:2722:1: ( ( rule__BooleanLiteral__Group__0 ) )
+            // InternalRoom.g:2723: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:2724:1: ( rule__BooleanLiteral__Group__0 )
+            // InternalRoom.g:2724:2: rule__BooleanLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__0();
@@ -7425,11 +7502,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalRoom.g:2710:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
+    // InternalRoom.g:2736: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:2737:1: ( ruleNumberLiteral EOF )
+            // InternalRoom.g:2738:1: ruleNumberLiteral EOF
             {
              before(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7455,21 +7532,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleNumberLiteral"
-    // InternalRoom.g:2719:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ;
+    // InternalRoom.g:2745: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:2749:2: ( ( ( rule__NumberLiteral__Alternatives ) ) )
+            // InternalRoom.g:2750:1: ( ( rule__NumberLiteral__Alternatives ) )
             {
-            // InternalRoom.g:2724:1: ( ( rule__NumberLiteral__Alternatives ) )
-            // InternalRoom.g:2725:1: ( rule__NumberLiteral__Alternatives )
+            // InternalRoom.g:2750:1: ( ( rule__NumberLiteral__Alternatives ) )
+            // InternalRoom.g:2751:1: ( rule__NumberLiteral__Alternatives )
             {
              before(grammarAccess.getNumberLiteralAccess().getAlternatives()); 
-            // InternalRoom.g:2726:1: ( rule__NumberLiteral__Alternatives )
-            // InternalRoom.g:2726:2: rule__NumberLiteral__Alternatives
+            // InternalRoom.g:2752:1: ( rule__NumberLiteral__Alternatives )
+            // InternalRoom.g:2752:2: rule__NumberLiteral__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__NumberLiteral__Alternatives();
@@ -7502,11 +7579,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalRoom.g:2738:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
+    // InternalRoom.g:2764: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:2765:1: ( ruleRealLiteral EOF )
+            // InternalRoom.g:2766:1: ruleRealLiteral EOF
             {
              before(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7532,21 +7609,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleRealLiteral"
-    // InternalRoom.g:2747:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2773: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:2777:2: ( ( ( rule__RealLiteral__Group__0 ) ) )
+            // InternalRoom.g:2778:1: ( ( rule__RealLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2752:1: ( ( rule__RealLiteral__Group__0 ) )
-            // InternalRoom.g:2753:1: ( rule__RealLiteral__Group__0 )
+            // InternalRoom.g:2778:1: ( ( rule__RealLiteral__Group__0 ) )
+            // InternalRoom.g:2779: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:2780:1: ( rule__RealLiteral__Group__0 )
+            // InternalRoom.g:2780:2: rule__RealLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__0();
@@ -7579,11 +7656,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalRoom.g:2766:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
+    // InternalRoom.g:2792: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:2793:1: ( ruleIntLiteral EOF )
+            // InternalRoom.g:2794:1: ruleIntLiteral EOF
             {
              before(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7609,21 +7686,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleIntLiteral"
-    // InternalRoom.g:2775:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2801: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:2805:2: ( ( ( rule__IntLiteral__Group__0 ) ) )
+            // InternalRoom.g:2806:1: ( ( rule__IntLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2780:1: ( ( rule__IntLiteral__Group__0 ) )
-            // InternalRoom.g:2781:1: ( rule__IntLiteral__Group__0 )
+            // InternalRoom.g:2806:1: ( ( rule__IntLiteral__Group__0 ) )
+            // InternalRoom.g:2807: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:2808:1: ( rule__IntLiteral__Group__0 )
+            // InternalRoom.g:2808:2: rule__IntLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__0();
@@ -7656,11 +7733,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalRoom.g:2794:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
+    // InternalRoom.g:2820: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:2821:1: ( ruleStringLiteral EOF )
+            // InternalRoom.g:2822:1: ruleStringLiteral EOF
             {
              before(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -7686,21 +7763,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleStringLiteral"
-    // InternalRoom.g:2803:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
+    // InternalRoom.g:2829: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:2833:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
+            // InternalRoom.g:2834:1: ( ( rule__StringLiteral__Group__0 ) )
             {
-            // InternalRoom.g:2808:1: ( ( rule__StringLiteral__Group__0 ) )
-            // InternalRoom.g:2809:1: ( rule__StringLiteral__Group__0 )
+            // InternalRoom.g:2834:1: ( ( rule__StringLiteral__Group__0 ) )
+            // InternalRoom.g:2835: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:2836:1: ( rule__StringLiteral__Group__0 )
+            // InternalRoom.g:2836:2: rule__StringLiteral__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__0();
@@ -7733,11 +7810,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalRoom.g:2822:1: entryRuleInteger : ruleInteger EOF ;
+    // InternalRoom.g:2848: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:2849:1: ( ruleInteger EOF )
+            // InternalRoom.g:2850:1: ruleInteger EOF
             {
              before(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -7763,21 +7840,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleInteger"
-    // InternalRoom.g:2831:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ;
+    // InternalRoom.g:2857: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:2861:2: ( ( ( rule__Integer__Alternatives ) ) )
+            // InternalRoom.g:2862:1: ( ( rule__Integer__Alternatives ) )
             {
-            // InternalRoom.g:2836:1: ( ( rule__Integer__Alternatives ) )
-            // InternalRoom.g:2837:1: ( rule__Integer__Alternatives )
+            // InternalRoom.g:2862:1: ( ( rule__Integer__Alternatives ) )
+            // InternalRoom.g:2863:1: ( rule__Integer__Alternatives )
             {
              before(grammarAccess.getIntegerAccess().getAlternatives()); 
-            // InternalRoom.g:2838:1: ( rule__Integer__Alternatives )
-            // InternalRoom.g:2838:2: rule__Integer__Alternatives
+            // InternalRoom.g:2864:1: ( rule__Integer__Alternatives )
+            // InternalRoom.g:2864:2: rule__Integer__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Alternatives();
@@ -7810,11 +7887,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalRoom.g:2850:1: entryRuleReal : ruleReal EOF ;
+    // InternalRoom.g:2876: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:2877:1: ( ruleReal EOF )
+            // InternalRoom.g:2878:1: ruleReal EOF
             {
              before(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -7840,21 +7917,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleReal"
-    // InternalRoom.g:2859:1: ruleReal : ( ( rule__Real__Alternatives ) ) ;
+    // InternalRoom.g:2885: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:2889:2: ( ( ( rule__Real__Alternatives ) ) )
+            // InternalRoom.g:2890:1: ( ( rule__Real__Alternatives ) )
             {
-            // InternalRoom.g:2864:1: ( ( rule__Real__Alternatives ) )
-            // InternalRoom.g:2865:1: ( rule__Real__Alternatives )
+            // InternalRoom.g:2890:1: ( ( rule__Real__Alternatives ) )
+            // InternalRoom.g:2891:1: ( rule__Real__Alternatives )
             {
              before(grammarAccess.getRealAccess().getAlternatives()); 
-            // InternalRoom.g:2866:1: ( rule__Real__Alternatives )
-            // InternalRoom.g:2866:2: rule__Real__Alternatives
+            // InternalRoom.g:2892:1: ( rule__Real__Alternatives )
+            // InternalRoom.g:2892:2: rule__Real__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__Real__Alternatives();
@@ -7887,14 +7964,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalRoom.g:2878:1: entryRuleDecimal : ruleDecimal EOF ;
+    // InternalRoom.g:2904: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:2908:1: ( ruleDecimal EOF )
+            // InternalRoom.g:2909:1: ruleDecimal EOF
             {
              before(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -7923,22 +8000,22 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimal"
-    // InternalRoom.g:2893:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ;
+    // InternalRoom.g:2919: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:2924:2: ( ( ( rule__Decimal__Group__0 ) ) )
+            // InternalRoom.g:2925:1: ( ( rule__Decimal__Group__0 ) )
             {
-            // InternalRoom.g:2899:1: ( ( rule__Decimal__Group__0 ) )
-            // InternalRoom.g:2900:1: ( rule__Decimal__Group__0 )
+            // InternalRoom.g:2925:1: ( ( rule__Decimal__Group__0 ) )
+            // InternalRoom.g:2926: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:2927:1: ( rule__Decimal__Group__0 )
+            // InternalRoom.g:2927:2: rule__Decimal__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__0();
@@ -7972,14 +8049,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalRoom.g:2914:1: entryRuleDecimalExp : ruleDecimalExp EOF ;
+    // InternalRoom.g:2940: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:2944:1: ( ruleDecimalExp EOF )
+            // InternalRoom.g:2945:1: ruleDecimalExp EOF
             {
              before(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -8008,22 +8085,22 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleDecimalExp"
-    // InternalRoom.g:2929:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ;
+    // InternalRoom.g:2955: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:2960:2: ( ( ( rule__DecimalExp__Group__0 ) ) )
+            // InternalRoom.g:2961:1: ( ( rule__DecimalExp__Group__0 ) )
             {
-            // InternalRoom.g:2935:1: ( ( rule__DecimalExp__Group__0 ) )
-            // InternalRoom.g:2936:1: ( rule__DecimalExp__Group__0 )
+            // InternalRoom.g:2961:1: ( ( rule__DecimalExp__Group__0 ) )
+            // InternalRoom.g:2962: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:2963:1: ( rule__DecimalExp__Group__0 )
+            // InternalRoom.g:2963:2: rule__DecimalExp__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__0();
@@ -8057,11 +8134,11 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalRoom.g:2950:1: entryRuleFQN : ruleFQN EOF ;
+    // InternalRoom.g:2976: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:2977:1: ( ruleFQN EOF )
+            // InternalRoom.g:2978:1: ruleFQN EOF
             {
              before(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -8087,21 +8164,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleFQN"
-    // InternalRoom.g:2959:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ;
+    // InternalRoom.g:2985: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:2989:2: ( ( ( rule__FQN__Group__0 ) ) )
+            // InternalRoom.g:2990:1: ( ( rule__FQN__Group__0 ) )
             {
-            // InternalRoom.g:2964:1: ( ( rule__FQN__Group__0 ) )
-            // InternalRoom.g:2965:1: ( rule__FQN__Group__0 )
+            // InternalRoom.g:2990:1: ( ( rule__FQN__Group__0 ) )
+            // InternalRoom.g:2991: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:2992:1: ( rule__FQN__Group__0 )
+            // InternalRoom.g:2992:2: rule__FQN__Group__0
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__0();
@@ -8134,21 +8211,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleCommunicationType"
-    // InternalRoom.g:2979:1: ruleCommunicationType : ( ( rule__CommunicationType__Alternatives ) ) ;
+    // InternalRoom.g:3005: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:3009:1: ( ( ( rule__CommunicationType__Alternatives ) ) )
+            // InternalRoom.g:3010:1: ( ( rule__CommunicationType__Alternatives ) )
             {
-            // InternalRoom.g:2984:1: ( ( rule__CommunicationType__Alternatives ) )
-            // InternalRoom.g:2985:1: ( rule__CommunicationType__Alternatives )
+            // InternalRoom.g:3010:1: ( ( rule__CommunicationType__Alternatives ) )
+            // InternalRoom.g:3011:1: ( rule__CommunicationType__Alternatives )
             {
              before(grammarAccess.getCommunicationTypeAccess().getAlternatives()); 
-            // InternalRoom.g:2986:1: ( rule__CommunicationType__Alternatives )
-            // InternalRoom.g:2986:2: rule__CommunicationType__Alternatives
+            // InternalRoom.g:3012:1: ( rule__CommunicationType__Alternatives )
+            // InternalRoom.g:3012:2: rule__CommunicationType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__CommunicationType__Alternatives();
@@ -8181,21 +8258,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleReferenceType"
-    // InternalRoom.g:2998:1: ruleReferenceType : ( ( rule__ReferenceType__Alternatives ) ) ;
+    // InternalRoom.g:3024: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:3028:1: ( ( ( rule__ReferenceType__Alternatives ) ) )
+            // InternalRoom.g:3029:1: ( ( rule__ReferenceType__Alternatives ) )
             {
-            // InternalRoom.g:3003:1: ( ( rule__ReferenceType__Alternatives ) )
-            // InternalRoom.g:3004:1: ( rule__ReferenceType__Alternatives )
+            // InternalRoom.g:3029:1: ( ( rule__ReferenceType__Alternatives ) )
+            // InternalRoom.g:3030:1: ( rule__ReferenceType__Alternatives )
             {
              before(grammarAccess.getReferenceTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3005:1: ( rule__ReferenceType__Alternatives )
-            // InternalRoom.g:3005:2: rule__ReferenceType__Alternatives
+            // InternalRoom.g:3031:1: ( rule__ReferenceType__Alternatives )
+            // InternalRoom.g:3031:2: rule__ReferenceType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ReferenceType__Alternatives();
@@ -8228,21 +8305,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleComponentCommunicationType"
-    // InternalRoom.g:3019:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ;
+    // InternalRoom.g:3045: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:3049:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) )
+            // InternalRoom.g:3050:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
             {
-            // InternalRoom.g:3024:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
-            // InternalRoom.g:3025:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalRoom.g:3050:1: ( ( rule__ComponentCommunicationType__Alternatives ) )
+            // InternalRoom.g:3051:1: ( rule__ComponentCommunicationType__Alternatives )
             {
              before(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3026:1: ( rule__ComponentCommunicationType__Alternatives )
-            // InternalRoom.g:3026:2: rule__ComponentCommunicationType__Alternatives
+            // InternalRoom.g:3052:1: ( rule__ComponentCommunicationType__Alternatives )
+            // InternalRoom.g:3052:2: rule__ComponentCommunicationType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__ComponentCommunicationType__Alternatives();
@@ -8275,21 +8352,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "ruleLiteralType"
-    // InternalRoom.g:3038:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ;
+    // InternalRoom.g:3064: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:3068:1: ( ( ( rule__LiteralType__Alternatives ) ) )
+            // InternalRoom.g:3069:1: ( ( rule__LiteralType__Alternatives ) )
             {
-            // InternalRoom.g:3043:1: ( ( rule__LiteralType__Alternatives ) )
-            // InternalRoom.g:3044:1: ( rule__LiteralType__Alternatives )
+            // InternalRoom.g:3069:1: ( ( rule__LiteralType__Alternatives ) )
+            // InternalRoom.g:3070:1: ( rule__LiteralType__Alternatives )
             {
              before(grammarAccess.getLiteralTypeAccess().getAlternatives()); 
-            // InternalRoom.g:3045:1: ( rule__LiteralType__Alternatives )
-            // InternalRoom.g:3045:2: rule__LiteralType__Alternatives
+            // InternalRoom.g:3071:1: ( rule__LiteralType__Alternatives )
+            // InternalRoom.g:3071:2: rule__LiteralType__Alternatives
             {
             pushFollow(FOLLOW_2);
             rule__LiteralType__Alternatives();
@@ -8322,25 +8399,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:3082: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:3086: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:3087: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:3087:1: ( ( rule__RoomModel__PrimitiveTypesAssignment_5_0 ) )
+                    // InternalRoom.g:3088: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:3089:1: ( rule__RoomModel__PrimitiveTypesAssignment_5_0 )
+                    // InternalRoom.g:3089:2: rule__RoomModel__PrimitiveTypesAssignment_5_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__PrimitiveTypesAssignment_5_0();
@@ -8358,14 +8435,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3067:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
+                    // InternalRoom.g:3093: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:3093:6: ( ( rule__RoomModel__EnumerationTypesAssignment_5_1 ) )
+                    // InternalRoom.g:3094: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:3095:1: ( rule__RoomModel__EnumerationTypesAssignment_5_1 )
+                    // InternalRoom.g:3095:2: rule__RoomModel__EnumerationTypesAssignment_5_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__EnumerationTypesAssignment_5_1();
@@ -8383,14 +8460,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3073:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
+                    // InternalRoom.g:3099: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:3099:6: ( ( rule__RoomModel__ExternalTypesAssignment_5_2 ) )
+                    // InternalRoom.g:3100: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:3101:1: ( rule__RoomModel__ExternalTypesAssignment_5_2 )
+                    // InternalRoom.g:3101:2: rule__RoomModel__ExternalTypesAssignment_5_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ExternalTypesAssignment_5_2();
@@ -8408,14 +8485,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3079:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
+                    // InternalRoom.g:3105: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:3105:6: ( ( rule__RoomModel__DataClassesAssignment_5_3 ) )
+                    // InternalRoom.g:3106: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:3107:1: ( rule__RoomModel__DataClassesAssignment_5_3 )
+                    // InternalRoom.g:3107:2: rule__RoomModel__DataClassesAssignment_5_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__DataClassesAssignment_5_3();
@@ -8433,14 +8510,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3085:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
+                    // InternalRoom.g:3111: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:3111:6: ( ( rule__RoomModel__ProtocolClassesAssignment_5_4 ) )
+                    // InternalRoom.g:3112: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:3113:1: ( rule__RoomModel__ProtocolClassesAssignment_5_4 )
+                    // InternalRoom.g:3113:2: rule__RoomModel__ProtocolClassesAssignment_5_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ProtocolClassesAssignment_5_4();
@@ -8458,14 +8535,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3091:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
+                    // InternalRoom.g:3117: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:3117:6: ( ( rule__RoomModel__ActorClassesAssignment_5_5 ) )
+                    // InternalRoom.g:3118: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:3119:1: ( rule__RoomModel__ActorClassesAssignment_5_5 )
+                    // InternalRoom.g:3119:2: rule__RoomModel__ActorClassesAssignment_5_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__ActorClassesAssignment_5_5();
@@ -8483,14 +8560,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3097:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
+                    // InternalRoom.g:3123: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:3123:6: ( ( rule__RoomModel__SubSystemClassesAssignment_5_6 ) )
+                    // InternalRoom.g:3124: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:3125:1: ( rule__RoomModel__SubSystemClassesAssignment_5_6 )
+                    // InternalRoom.g:3125:2: rule__RoomModel__SubSystemClassesAssignment_5_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__SubSystemClassesAssignment_5_6();
@@ -8508,14 +8585,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3103:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
+                    // InternalRoom.g:3129: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:3129:6: ( ( rule__RoomModel__SystemsAssignment_5_7 ) )
+                    // InternalRoom.g:3130: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:3131:1: ( rule__RoomModel__SystemsAssignment_5_7 )
+                    // InternalRoom.g:3131:2: rule__RoomModel__SystemsAssignment_5_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__SystemsAssignment_5_7();
@@ -8533,14 +8610,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 9 :
-                    // InternalRoom.g:3109:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
+                    // InternalRoom.g:3135: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:3135:6: ( ( rule__RoomModel__AnnotationTypesAssignment_5_8 ) )
+                    // InternalRoom.g:3136: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:3137:1: ( rule__RoomModel__AnnotationTypesAssignment_5_8 )
+                    // InternalRoom.g:3137:2: rule__RoomModel__AnnotationTypesAssignment_5_8
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__AnnotationTypesAssignment_5_8();
@@ -8575,13 +8652,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StructureClass__Alternatives"
-    // InternalRoom.g:3121:1: rule__StructureClass__Alternatives : ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) );
+    // InternalRoom.g:3147: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:3151:1: ( ( ruleActorContainerClass ) | ( ruleLogicalSystem ) )
             int alt2=2;
             int LA2_0 = input.LA(1);
 
@@ -8599,10 +8676,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt2) {
                 case 1 :
-                    // InternalRoom.g:3126:1: ( ruleActorContainerClass )
+                    // InternalRoom.g:3152:1: ( ruleActorContainerClass )
                     {
-                    // InternalRoom.g:3126:1: ( ruleActorContainerClass )
-                    // InternalRoom.g:3127:1: ruleActorContainerClass
+                    // InternalRoom.g:3152:1: ( ruleActorContainerClass )
+                    // InternalRoom.g:3153:1: ruleActorContainerClass
                     {
                      before(grammarAccess.getStructureClassAccess().getActorContainerClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8618,10 +8695,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3132:6: ( ruleLogicalSystem )
+                    // InternalRoom.g:3158:6: ( ruleLogicalSystem )
                     {
-                    // InternalRoom.g:3132:6: ( ruleLogicalSystem )
-                    // InternalRoom.g:3133:1: ruleLogicalSystem
+                    // InternalRoom.g:3158:6: ( ruleLogicalSystem )
+                    // InternalRoom.g:3159:1: ruleLogicalSystem
                     {
                      before(grammarAccess.getStructureClassAccess().getLogicalSystemParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8654,13 +8731,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorContainerClass__Alternatives"
-    // InternalRoom.g:3143:1: rule__ActorContainerClass__Alternatives : ( ( ruleActorClass ) | ( ruleSubSystemClass ) );
+    // InternalRoom.g:3169: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:3173:1: ( ( ruleActorClass ) | ( ruleSubSystemClass ) )
             int alt3=2;
             int LA3_0 = input.LA(1);
 
@@ -8678,10 +8755,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt3) {
                 case 1 :
-                    // InternalRoom.g:3148:1: ( ruleActorClass )
+                    // InternalRoom.g:3174:1: ( ruleActorClass )
                     {
-                    // InternalRoom.g:3148:1: ( ruleActorClass )
-                    // InternalRoom.g:3149:1: ruleActorClass
+                    // InternalRoom.g:3174:1: ( ruleActorClass )
+                    // InternalRoom.g:3175:1: ruleActorClass
                     {
                      before(grammarAccess.getActorContainerClassAccess().getActorClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8697,10 +8774,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3154:6: ( ruleSubSystemClass )
+                    // InternalRoom.g:3180:6: ( ruleSubSystemClass )
                     {
-                    // InternalRoom.g:3154:6: ( ruleSubSystemClass )
-                    // InternalRoom.g:3155:1: ruleSubSystemClass
+                    // InternalRoom.g:3180:6: ( ruleSubSystemClass )
+                    // InternalRoom.g:3181:1: ruleSubSystemClass
                     {
                      before(grammarAccess.getActorContainerClassAccess().getSubSystemClassParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8733,13 +8810,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataType__Alternatives"
-    // InternalRoom.g:3165:1: rule__DataType__Alternatives : ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) );
+    // InternalRoom.g:3191: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:3195:1: ( ( rulePrimitiveType ) | ( ruleEnumerationType ) | ( ruleComplexType ) )
             int alt4=3;
             switch ( input.LA(1) ) {
             case 47:
@@ -8767,10 +8844,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt4) {
                 case 1 :
-                    // InternalRoom.g:3170:1: ( rulePrimitiveType )
+                    // InternalRoom.g:3196:1: ( rulePrimitiveType )
                     {
-                    // InternalRoom.g:3170:1: ( rulePrimitiveType )
-                    // InternalRoom.g:3171:1: rulePrimitiveType
+                    // InternalRoom.g:3196:1: ( rulePrimitiveType )
+                    // InternalRoom.g:3197:1: rulePrimitiveType
                     {
                      before(grammarAccess.getDataTypeAccess().getPrimitiveTypeParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8786,10 +8863,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3176:6: ( ruleEnumerationType )
+                    // InternalRoom.g:3202:6: ( ruleEnumerationType )
                     {
-                    // InternalRoom.g:3176:6: ( ruleEnumerationType )
-                    // InternalRoom.g:3177:1: ruleEnumerationType
+                    // InternalRoom.g:3202:6: ( ruleEnumerationType )
+                    // InternalRoom.g:3203:1: ruleEnumerationType
                     {
                      before(grammarAccess.getDataTypeAccess().getEnumerationTypeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8805,10 +8882,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3182:6: ( ruleComplexType )
+                    // InternalRoom.g:3208:6: ( ruleComplexType )
                     {
-                    // InternalRoom.g:3182:6: ( ruleComplexType )
-                    // InternalRoom.g:3183:1: ruleComplexType
+                    // InternalRoom.g:3208:6: ( ruleComplexType )
+                    // InternalRoom.g:3209:1: ruleComplexType
                     {
                      before(grammarAccess.getDataTypeAccess().getComplexTypeParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -8841,13 +8918,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ComplexType__Alternatives"
-    // InternalRoom.g:3193:1: rule__ComplexType__Alternatives : ( ( ruleDataClass ) | ( ruleExternalType ) );
+    // InternalRoom.g:3219: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:3223:1: ( ( ruleDataClass ) | ( ruleExternalType ) )
             int alt5=2;
             int LA5_0 = input.LA(1);
 
@@ -8865,10 +8942,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt5) {
                 case 1 :
-                    // InternalRoom.g:3198:1: ( ruleDataClass )
+                    // InternalRoom.g:3224:1: ( ruleDataClass )
                     {
-                    // InternalRoom.g:3198:1: ( ruleDataClass )
-                    // InternalRoom.g:3199:1: ruleDataClass
+                    // InternalRoom.g:3224:1: ( ruleDataClass )
+                    // InternalRoom.g:3225:1: ruleDataClass
                     {
                      before(grammarAccess.getComplexTypeAccess().getDataClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -8884,10 +8961,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3204:6: ( ruleExternalType )
+                    // InternalRoom.g:3230:6: ( ruleExternalType )
                     {
-                    // InternalRoom.g:3204:6: ( ruleExternalType )
-                    // InternalRoom.g:3205:1: ruleExternalType
+                    // InternalRoom.g:3230:6: ( ruleExternalType )
+                    // InternalRoom.g:3231:1: ruleExternalType
                     {
                      before(grammarAccess.getComplexTypeAccess().getExternalTypeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -8920,13 +8997,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:3241: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:3245: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 +9032,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt6) {
                 case 1 :
-                    // InternalRoom.g:3220:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
+                    // InternalRoom.g:3246: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:3246:1: ( ( rule__DataClass__OperationsAssignment_9_0 ) )
+                    // InternalRoom.g:3247: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:3248:1: ( rule__DataClass__OperationsAssignment_9_0 )
+                    // InternalRoom.g:3248:2: rule__DataClass__OperationsAssignment_9_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__OperationsAssignment_9_0();
@@ -8980,14 +9057,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3226:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
+                    // InternalRoom.g:3252: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:3252:6: ( ( rule__DataClass__StructorsAssignment_9_1 ) )
+                    // InternalRoom.g:3253: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:3254:1: ( rule__DataClass__StructorsAssignment_9_1 )
+                    // InternalRoom.g:3254:2: rule__DataClass__StructorsAssignment_9_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__StructorsAssignment_9_1();
@@ -9005,14 +9082,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3232:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
+                    // InternalRoom.g:3258: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:3258:6: ( ( rule__DataClass__AttributesAssignment_9_2 ) )
+                    // InternalRoom.g:3259: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:3260:1: ( rule__DataClass__AttributesAssignment_9_2 )
+                    // InternalRoom.g:3260:2: rule__DataClass__AttributesAssignment_9_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__AttributesAssignment_9_2();
@@ -9047,13 +9124,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:3270: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:3274:1: ( ( 'void' ) | ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) ) )
             int alt7=2;
             int LA7_0 = input.LA(1);
 
@@ -9071,10 +9148,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt7) {
                 case 1 :
-                    // InternalRoom.g:3249:1: ( 'void' )
+                    // InternalRoom.g:3275:1: ( 'void' )
                     {
-                    // InternalRoom.g:3249:1: ( 'void' )
-                    // InternalRoom.g:3250:1: 'void'
+                    // InternalRoom.g:3275:1: ( 'void' )
+                    // InternalRoom.g:3276:1: 'void'
                     {
                      before(grammarAccess.getStandardOperationAccess().getVoidKeyword_6_1_0()); 
                     match(input,13,FOLLOW_2); 
@@ -9086,14 +9163,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3257:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
+                    // InternalRoom.g:3283: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:3283:6: ( ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 ) )
+                    // InternalRoom.g:3284: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:3285:1: ( rule__StandardOperation__ReturnTypeAssignment_6_1_1 )
+                    // InternalRoom.g:3285:2: rule__StandardOperation__ReturnTypeAssignment_6_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__ReturnTypeAssignment_6_1_1();
@@ -9128,13 +9205,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:3294: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:3298:1: ( ( ( rule__PortOperation__Group_5_0__0 ) ) | ( ( rule__PortOperation__Group_5_1__0 ) ) )
             int alt8=2;
             int LA8_0 = input.LA(1);
 
@@ -9152,14 +9229,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt8) {
                 case 1 :
-                    // InternalRoom.g:3273:1: ( ( rule__PortOperation__Group_5_0__0 ) )
+                    // InternalRoom.g:3299: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:3299:1: ( ( rule__PortOperation__Group_5_0__0 ) )
+                    // InternalRoom.g:3300: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:3301:1: ( rule__PortOperation__Group_5_0__0 )
+                    // InternalRoom.g:3301:2: rule__PortOperation__Group_5_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_5_0__0();
@@ -9177,14 +9254,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3279:6: ( ( rule__PortOperation__Group_5_1__0 ) )
+                    // InternalRoom.g:3305: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:3305:6: ( ( rule__PortOperation__Group_5_1__0 ) )
+                    // InternalRoom.g:3306: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:3307:1: ( rule__PortOperation__Group_5_1__0 )
+                    // InternalRoom.g:3307:2: rule__PortOperation__Group_5_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_5_1__0();
@@ -9219,13 +9296,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:3316: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:3320:1: ( ( 'void' ) | ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) ) )
             int alt9=2;
             int LA9_0 = input.LA(1);
 
@@ -9243,10 +9320,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt9) {
                 case 1 :
-                    // InternalRoom.g:3295:1: ( 'void' )
+                    // InternalRoom.g:3321:1: ( 'void' )
                     {
-                    // InternalRoom.g:3295:1: ( 'void' )
-                    // InternalRoom.g:3296:1: 'void'
+                    // InternalRoom.g:3321:1: ( 'void' )
+                    // InternalRoom.g:3322:1: 'void'
                     {
                      before(grammarAccess.getPortOperationAccess().getVoidKeyword_5_0_1_0()); 
                     match(input,13,FOLLOW_2); 
@@ -9258,14 +9335,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3303:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
+                    // InternalRoom.g:3329: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:3329:6: ( ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 ) )
+                    // InternalRoom.g:3330: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:3331:1: ( rule__PortOperation__ReturnTypeAssignment_5_0_1_1 )
+                    // InternalRoom.g:3331:2: rule__PortOperation__ReturnTypeAssignment_5_0_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__ReturnTypeAssignment_5_0_1_1();
@@ -9300,13 +9377,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:3340: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:3344:1: ( ( 'ctor' ) | ( 'dtor' ) )
             int alt10=2;
             int LA10_0 = input.LA(1);
 
@@ -9324,10 +9401,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt10) {
                 case 1 :
-                    // InternalRoom.g:3319:1: ( 'ctor' )
+                    // InternalRoom.g:3345:1: ( 'ctor' )
                     {
-                    // InternalRoom.g:3319:1: ( 'ctor' )
-                    // InternalRoom.g:3320:1: 'ctor'
+                    // InternalRoom.g:3345:1: ( 'ctor' )
+                    // InternalRoom.g:3346:1: 'ctor'
                     {
                      before(grammarAccess.getClassStructorAccess().getNameCtorKeyword_0_0_0()); 
                     match(input,14,FOLLOW_2); 
@@ -9339,10 +9416,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3327:6: ( 'dtor' )
+                    // InternalRoom.g:3353:6: ( 'dtor' )
                     {
-                    // InternalRoom.g:3327:6: ( 'dtor' )
-                    // InternalRoom.g:3328:1: 'dtor'
+                    // InternalRoom.g:3353:6: ( 'dtor' )
+                    // InternalRoom.g:3354:1: 'dtor'
                     {
                      before(grammarAccess.getClassStructorAccess().getNameDtorKeyword_0_0_1()); 
                     match(input,15,FOLLOW_2); 
@@ -9371,13 +9448,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GeneralProtocolClass__Alternatives"
-    // InternalRoom.g:3340:1: rule__GeneralProtocolClass__Alternatives : ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) );
+    // InternalRoom.g:3366: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:3370:1: ( ( ruleProtocolClass ) | ( ruleCompoundProtocolClass ) )
             int alt11=2;
             int LA11_0 = input.LA(1);
 
@@ -9395,10 +9472,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt11) {
                 case 1 :
-                    // InternalRoom.g:3345:1: ( ruleProtocolClass )
+                    // InternalRoom.g:3371:1: ( ruleProtocolClass )
                     {
-                    // InternalRoom.g:3345:1: ( ruleProtocolClass )
-                    // InternalRoom.g:3346:1: ruleProtocolClass
+                    // InternalRoom.g:3371:1: ( ruleProtocolClass )
+                    // InternalRoom.g:3372:1: ruleProtocolClass
                     {
                      before(grammarAccess.getGeneralProtocolClassAccess().getProtocolClassParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -9414,10 +9491,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3351:6: ( ruleCompoundProtocolClass )
+                    // InternalRoom.g:3377:6: ( ruleCompoundProtocolClass )
                     {
-                    // InternalRoom.g:3351:6: ( ruleCompoundProtocolClass )
-                    // InternalRoom.g:3352:1: ruleCompoundProtocolClass
+                    // InternalRoom.g:3377:6: ( ruleCompoundProtocolClass )
+                    // InternalRoom.g:3378:1: ruleCompoundProtocolClass
                     {
                      before(grammarAccess.getGeneralProtocolClassAccess().getCompoundProtocolClassParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -9450,13 +9527,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:3388: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:3392: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 +9560,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt12) {
                 case 1 :
-                    // InternalRoom.g:3367:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
+                    // InternalRoom.g:3393: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:3393:1: ( ( rule__PortClass__MsgHandlersAssignment_3_0 ) )
+                    // InternalRoom.g:3394: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:3395:1: ( rule__PortClass__MsgHandlersAssignment_3_0 )
+                    // InternalRoom.g:3395:2: rule__PortClass__MsgHandlersAssignment_3_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__MsgHandlersAssignment_3_0();
@@ -9508,14 +9585,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3373:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
+                    // InternalRoom.g:3399: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:3399:6: ( ( rule__PortClass__OperationsAssignment_3_1 ) )
+                    // InternalRoom.g:3400: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:3401:1: ( rule__PortClass__OperationsAssignment_3_1 )
+                    // InternalRoom.g:3401:2: rule__PortClass__OperationsAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__OperationsAssignment_3_1();
@@ -9533,14 +9610,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3379:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
+                    // InternalRoom.g:3405: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:3405:6: ( ( rule__PortClass__AttributesAssignment_3_2 ) )
+                    // InternalRoom.g:3406: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:3407:1: ( rule__PortClass__AttributesAssignment_3_2 )
+                    // InternalRoom.g:3407:2: rule__PortClass__AttributesAssignment_3_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__AttributesAssignment_3_2();
@@ -9575,13 +9652,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageHandler__Alternatives"
-    // InternalRoom.g:3390:1: rule__MessageHandler__Alternatives : ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) );
+    // InternalRoom.g:3416: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:3420:1: ( ( ruleInMessageHandler ) | ( ruleOutMessageHandler ) )
             int alt13=2;
             int LA13_0 = input.LA(1);
 
@@ -9609,10 +9686,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt13) {
                 case 1 :
-                    // InternalRoom.g:3395:1: ( ruleInMessageHandler )
+                    // InternalRoom.g:3421:1: ( ruleInMessageHandler )
                     {
-                    // InternalRoom.g:3395:1: ( ruleInMessageHandler )
-                    // InternalRoom.g:3396:1: ruleInMessageHandler
+                    // InternalRoom.g:3421:1: ( ruleInMessageHandler )
+                    // InternalRoom.g:3422:1: ruleInMessageHandler
                     {
                      before(grammarAccess.getMessageHandlerAccess().getInMessageHandlerParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -9628,10 +9705,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3401:6: ( ruleOutMessageHandler )
+                    // InternalRoom.g:3427:6: ( ruleOutMessageHandler )
                     {
-                    // InternalRoom.g:3401:6: ( ruleOutMessageHandler )
-                    // InternalRoom.g:3402:1: ruleOutMessageHandler
+                    // InternalRoom.g:3427:6: ( ruleOutMessageHandler )
+                    // InternalRoom.g:3428:1: ruleOutMessageHandler
                     {
                      before(grammarAccess.getMessageHandlerAccess().getOutMessageHandlerParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -9664,13 +9741,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:3438: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:3442:1: ( ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) ) | ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) ) )
             int alt14=2;
             int LA14_0 = input.LA(1);
 
@@ -9688,14 +9765,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt14) {
                 case 1 :
-                    // InternalRoom.g:3417:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
+                    // InternalRoom.g:3443: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:3443:1: ( ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 ) )
+                    // InternalRoom.g:3444: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:3445:1: ( rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0 )
+                    // InternalRoom.g:3445:2: rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0();
@@ -9713,14 +9790,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3423:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
+                    // InternalRoom.g:3449: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:3449:6: ( ( rule__ActorClass__InterfacePortsAssignment_7_2_1 ) )
+                    // InternalRoom.g:3450: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:3451:1: ( rule__ActorClass__InterfacePortsAssignment_7_2_1 )
+                    // InternalRoom.g:3451:2: rule__ActorClass__InterfacePortsAssignment_7_2_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__InterfacePortsAssignment_7_2_1();
@@ -9755,13 +9832,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:3460: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:3464: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 +9893,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt15) {
                 case 1 :
-                    // InternalRoom.g:3439:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
+                    // InternalRoom.g:3465: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:3465:1: ( ( rule__ActorClass__ConnectionsAssignment_8_6_0 ) )
+                    // InternalRoom.g:3466: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:3467:1: ( rule__ActorClass__ConnectionsAssignment_8_6_0 )
+                    // InternalRoom.g:3467:2: rule__ActorClass__ConnectionsAssignment_8_6_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ConnectionsAssignment_8_6_0();
@@ -9841,14 +9918,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3445:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
+                    // InternalRoom.g:3471: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:3471:6: ( ( rule__ActorClass__BindingsAssignment_8_6_1 ) )
+                    // InternalRoom.g:3472: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:3473:1: ( rule__ActorClass__BindingsAssignment_8_6_1 )
+                    // InternalRoom.g:3473:2: rule__ActorClass__BindingsAssignment_8_6_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__BindingsAssignment_8_6_1();
@@ -9866,14 +9943,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3451:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
+                    // InternalRoom.g:3477: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:3477:6: ( ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 ) )
+                    // InternalRoom.g:3478: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:3479:1: ( rule__ActorClass__ServiceImplementationsAssignment_8_6_2 )
+                    // InternalRoom.g:3479:2: rule__ActorClass__ServiceImplementationsAssignment_8_6_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceImplementationsAssignment_8_6_2();
@@ -9891,14 +9968,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3457:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
+                    // InternalRoom.g:3483: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:3483:6: ( ( rule__ActorClass__AttributesAssignment_8_6_3 ) )
+                    // InternalRoom.g:3484: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:3485:1: ( rule__ActorClass__AttributesAssignment_8_6_3 )
+                    // InternalRoom.g:3485:2: rule__ActorClass__AttributesAssignment_8_6_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__AttributesAssignment_8_6_3();
@@ -9916,14 +9993,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3463:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
+                    // InternalRoom.g:3489: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:3489:6: ( ( rule__ActorClass__ActorRefsAssignment_8_6_4 ) )
+                    // InternalRoom.g:3490: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:3491:1: ( rule__ActorClass__ActorRefsAssignment_8_6_4 )
+                    // InternalRoom.g:3491:2: rule__ActorClass__ActorRefsAssignment_8_6_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ActorRefsAssignment_8_6_4();
@@ -9941,14 +10018,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3469:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
+                    // InternalRoom.g:3495: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:3495:6: ( ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 ) )
+                    // InternalRoom.g:3496: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:3497:1: ( rule__ActorClass__ServiceAccessPointsAssignment_8_6_5 )
+                    // InternalRoom.g:3497:2: rule__ActorClass__ServiceAccessPointsAssignment_8_6_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ServiceAccessPointsAssignment_8_6_5();
@@ -9966,14 +10043,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3475:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
+                    // InternalRoom.g:3501: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:3501:6: ( ( rule__ActorClass__InternalPortsAssignment_8_6_6 ) )
+                    // InternalRoom.g:3502: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:3503:1: ( rule__ActorClass__InternalPortsAssignment_8_6_6 )
+                    // InternalRoom.g:3503:2: rule__ActorClass__InternalPortsAssignment_8_6_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__InternalPortsAssignment_8_6_6();
@@ -9991,14 +10068,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3481:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
+                    // InternalRoom.g:3507: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:3507:6: ( ( rule__ActorClass__ExternalPortsAssignment_8_6_7 ) )
+                    // InternalRoom.g:3508: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:3509:1: ( rule__ActorClass__ExternalPortsAssignment_8_6_7 )
+                    // InternalRoom.g:3509:2: rule__ActorClass__ExternalPortsAssignment_8_6_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__ExternalPortsAssignment_8_6_7();
@@ -10033,13 +10110,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:3518: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:3522:1: ( ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) ) | ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) ) )
             int alt16=2;
             int LA16_0 = input.LA(1);
 
@@ -10057,14 +10134,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt16) {
                 case 1 :
-                    // InternalRoom.g:3497:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
+                    // InternalRoom.g:3523: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:3523:1: ( ( rule__ActorClass__OperationsAssignment_9_4_0 ) )
+                    // InternalRoom.g:3524: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:3525:1: ( rule__ActorClass__OperationsAssignment_9_4_0 )
+                    // InternalRoom.g:3525:2: rule__ActorClass__OperationsAssignment_9_4_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__OperationsAssignment_9_4_0();
@@ -10082,14 +10159,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3503:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
+                    // InternalRoom.g:3529: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:3529:6: ( ( rule__ActorClass__StructorsAssignment_9_4_1 ) )
+                    // InternalRoom.g:3530: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:3531:1: ( rule__ActorClass__StructorsAssignment_9_4_1 )
+                    // InternalRoom.g:3531:2: rule__ActorClass__StructorsAssignment_9_4_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StructorsAssignment_9_4_1();
@@ -10124,13 +10201,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InterfaceItem__Alternatives"
-    // InternalRoom.g:3514:1: rule__InterfaceItem__Alternatives : ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) );
+    // InternalRoom.g:3540: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:3544:1: ( ( rulePort ) | ( ruleSAP ) | ( ruleSPP ) )
             int alt17=3;
             switch ( input.LA(1) ) {
             case 24:
@@ -10158,10 +10235,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt17) {
                 case 1 :
-                    // InternalRoom.g:3519:1: ( rulePort )
+                    // InternalRoom.g:3545:1: ( rulePort )
                     {
-                    // InternalRoom.g:3519:1: ( rulePort )
-                    // InternalRoom.g:3520:1: rulePort
+                    // InternalRoom.g:3545:1: ( rulePort )
+                    // InternalRoom.g:3546:1: rulePort
                     {
                      before(grammarAccess.getInterfaceItemAccess().getPortParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -10177,10 +10254,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3525:6: ( ruleSAP )
+                    // InternalRoom.g:3551:6: ( ruleSAP )
                     {
-                    // InternalRoom.g:3525:6: ( ruleSAP )
-                    // InternalRoom.g:3526:1: ruleSAP
+                    // InternalRoom.g:3551:6: ( ruleSAP )
+                    // InternalRoom.g:3552:1: ruleSAP
                     {
                      before(grammarAccess.getInterfaceItemAccess().getSAPParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -10196,10 +10273,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3531:6: ( ruleSPP )
+                    // InternalRoom.g:3557:6: ( ruleSPP )
                     {
-                    // InternalRoom.g:3531:6: ( ruleSPP )
-                    // InternalRoom.g:3532:1: ruleSPP
+                    // InternalRoom.g:3557:6: ( ruleSPP )
+                    // InternalRoom.g:3558:1: ruleSPP
                     {
                      before(grammarAccess.getInterfaceItemAccess().getSPPParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -10232,13 +10309,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:3568: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:3572: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 +10342,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt18) {
                 case 1 :
-                    // InternalRoom.g:3547:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
+                    // InternalRoom.g:3573: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:3573:1: ( ( rule__LogicalSystem__ConnectionsAssignment_5_0 ) )
+                    // InternalRoom.g:3574: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:3575:1: ( rule__LogicalSystem__ConnectionsAssignment_5_0 )
+                    // InternalRoom.g:3575:2: rule__LogicalSystem__ConnectionsAssignment_5_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__ConnectionsAssignment_5_0();
@@ -10290,14 +10367,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3553:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
+                    // InternalRoom.g:3579: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:3579:6: ( ( rule__LogicalSystem__BindingsAssignment_5_1 ) )
+                    // InternalRoom.g:3580: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:3581:1: ( rule__LogicalSystem__BindingsAssignment_5_1 )
+                    // InternalRoom.g:3581:2: rule__LogicalSystem__BindingsAssignment_5_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__BindingsAssignment_5_1();
@@ -10315,14 +10392,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3559:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
+                    // InternalRoom.g:3585: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:3585:6: ( ( rule__LogicalSystem__SubSystemsAssignment_5_2 ) )
+                    // InternalRoom.g:3586: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:3587:1: ( rule__LogicalSystem__SubSystemsAssignment_5_2 )
+                    // InternalRoom.g:3587:2: rule__LogicalSystem__SubSystemsAssignment_5_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__SubSystemsAssignment_5_2();
@@ -10357,13 +10434,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:3597: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:3601: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 +10490,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt19) {
                 case 1 :
-                    // InternalRoom.g:3576:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
+                    // InternalRoom.g:3602: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:3602:1: ( ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 ) )
+                    // InternalRoom.g:3603: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:3604:1: ( rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0 )
+                    // InternalRoom.g:3604:2: rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0();
@@ -10438,14 +10515,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3582:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
+                    // InternalRoom.g:3608: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:3608:6: ( ( rule__SubSystemClass__ThreadsAssignment_8_1 ) )
+                    // InternalRoom.g:3609: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:3610:1: ( rule__SubSystemClass__ThreadsAssignment_8_1 )
+                    // InternalRoom.g:3610:2: rule__SubSystemClass__ThreadsAssignment_8_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ThreadsAssignment_8_1();
@@ -10463,14 +10540,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3588:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
+                    // InternalRoom.g:3614: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:3614:6: ( ( rule__SubSystemClass__ConnectionsAssignment_8_2 ) )
+                    // InternalRoom.g:3615: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:3616:1: ( rule__SubSystemClass__ConnectionsAssignment_8_2 )
+                    // InternalRoom.g:3616:2: rule__SubSystemClass__ConnectionsAssignment_8_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ConnectionsAssignment_8_2();
@@ -10488,14 +10565,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3594:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
+                    // InternalRoom.g:3620: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:3620:6: ( ( rule__SubSystemClass__BindingsAssignment_8_3 ) )
+                    // InternalRoom.g:3621: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:3622:1: ( rule__SubSystemClass__BindingsAssignment_8_3 )
+                    // InternalRoom.g:3622:2: rule__SubSystemClass__BindingsAssignment_8_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__BindingsAssignment_8_3();
@@ -10513,14 +10590,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3600:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
+                    // InternalRoom.g:3626: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:3626:6: ( ( rule__SubSystemClass__ActorRefsAssignment_8_4 ) )
+                    // InternalRoom.g:3627: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:3628:1: ( rule__SubSystemClass__ActorRefsAssignment_8_4 )
+                    // InternalRoom.g:3628:2: rule__SubSystemClass__ActorRefsAssignment_8_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ActorRefsAssignment_8_4();
@@ -10538,14 +10615,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3606:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
+                    // InternalRoom.g:3632: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:3632:6: ( ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 ) )
+                    // InternalRoom.g:3633: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:3634:1: ( rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5 )
+                    // InternalRoom.g:3634:2: rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5();
@@ -10563,14 +10640,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3612:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
+                    // InternalRoom.g:3638: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:3638:6: ( ( rule__SubSystemClass__RelayPortsAssignment_8_6 ) )
+                    // InternalRoom.g:3639: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:3640:1: ( rule__SubSystemClass__RelayPortsAssignment_8_6 )
+                    // InternalRoom.g:3640:2: rule__SubSystemClass__RelayPortsAssignment_8_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__RelayPortsAssignment_8_6();
@@ -10605,13 +10682,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAPoint__Alternatives"
-    // InternalRoom.g:3623:1: rule__SAPoint__Alternatives : ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) );
+    // InternalRoom.g:3649: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:3653:1: ( ( ruleRefSAPoint ) | ( ruleRelaySAPoint ) )
             int alt20=2;
             int LA20_0 = input.LA(1);
 
@@ -10629,10 +10706,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt20) {
                 case 1 :
-                    // InternalRoom.g:3628:1: ( ruleRefSAPoint )
+                    // InternalRoom.g:3654:1: ( ruleRefSAPoint )
                     {
-                    // InternalRoom.g:3628:1: ( ruleRefSAPoint )
-                    // InternalRoom.g:3629:1: ruleRefSAPoint
+                    // InternalRoom.g:3654:1: ( ruleRefSAPoint )
+                    // InternalRoom.g:3655:1: ruleRefSAPoint
                     {
                      before(grammarAccess.getSAPointAccess().getRefSAPointParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -10648,10 +10725,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3634:6: ( ruleRelaySAPoint )
+                    // InternalRoom.g:3660:6: ( ruleRelaySAPoint )
                     {
-                    // InternalRoom.g:3634:6: ( ruleRelaySAPoint )
-                    // InternalRoom.g:3635:1: ruleRelaySAPoint
+                    // InternalRoom.g:3660:6: ( ruleRelaySAPoint )
+                    // InternalRoom.g:3661:1: ruleRelaySAPoint
                     {
                      before(grammarAccess.getSAPointAccess().getRelaySAPointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -10684,13 +10761,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Alternatives_1"
-    // InternalRoom.g:3645:1: rule__MULTIPLICITY__Alternatives_1 : ( ( '*' ) | ( RULE_INT ) );
+    // InternalRoom.g:3671: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:3675:1: ( ( '*' ) | ( RULE_INT ) )
             int alt21=2;
             int LA21_0 = input.LA(1);
 
@@ -10708,10 +10785,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt21) {
                 case 1 :
-                    // InternalRoom.g:3650:1: ( '*' )
+                    // InternalRoom.g:3676:1: ( '*' )
                     {
-                    // InternalRoom.g:3650:1: ( '*' )
-                    // InternalRoom.g:3651:1: '*'
+                    // InternalRoom.g:3676:1: ( '*' )
+                    // InternalRoom.g:3677:1: '*'
                     {
                      before(grammarAccess.getMULTIPLICITYAccess().getAsteriskKeyword_1_0()); 
                     match(input,16,FOLLOW_2); 
@@ -10723,10 +10800,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3658:6: ( RULE_INT )
+                    // InternalRoom.g:3684:6: ( RULE_INT )
                     {
-                    // InternalRoom.g:3658:6: ( RULE_INT )
-                    // InternalRoom.g:3659:1: RULE_INT
+                    // InternalRoom.g:3684:6: ( RULE_INT )
+                    // InternalRoom.g:3685:1: RULE_INT
                     {
                      before(grammarAccess.getMULTIPLICITYAccess().getINTTerminalRuleCall_1_1()); 
                     match(input,RULE_INT,FOLLOW_2); 
@@ -10755,13 +10832,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:3695: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:3699:1: ( ( 'DataClass' ) | ( 'ActorClass' ) | ( 'ActorBehavior' ) | ( 'ProtocolClass' ) | ( 'CompoundProtocolClass' ) | ( 'SubSystemClass' ) | ( 'LogicalSystem' ) | ( 'Port' ) | ( 'Message' ) )
             int alt22=9;
             switch ( input.LA(1) ) {
             case 17:
@@ -10818,10 +10895,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt22) {
                 case 1 :
-                    // InternalRoom.g:3674:1: ( 'DataClass' )
+                    // InternalRoom.g:3700:1: ( 'DataClass' )
                     {
-                    // InternalRoom.g:3674:1: ( 'DataClass' )
-                    // InternalRoom.g:3675:1: 'DataClass'
+                    // InternalRoom.g:3700:1: ( 'DataClass' )
+                    // InternalRoom.g:3701:1: 'DataClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getDataClassKeyword_0()); 
                     match(input,17,FOLLOW_2); 
@@ -10833,10 +10910,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3682:6: ( 'ActorClass' )
+                    // InternalRoom.g:3708:6: ( 'ActorClass' )
                     {
-                    // InternalRoom.g:3682:6: ( 'ActorClass' )
-                    // InternalRoom.g:3683:1: 'ActorClass'
+                    // InternalRoom.g:3708:6: ( 'ActorClass' )
+                    // InternalRoom.g:3709:1: 'ActorClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getActorClassKeyword_1()); 
                     match(input,18,FOLLOW_2); 
@@ -10848,10 +10925,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3690:6: ( 'ActorBehavior' )
+                    // InternalRoom.g:3716:6: ( 'ActorBehavior' )
                     {
-                    // InternalRoom.g:3690:6: ( 'ActorBehavior' )
-                    // InternalRoom.g:3691:1: 'ActorBehavior'
+                    // InternalRoom.g:3716:6: ( 'ActorBehavior' )
+                    // InternalRoom.g:3717:1: 'ActorBehavior'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getActorBehaviorKeyword_2()); 
                     match(input,19,FOLLOW_2); 
@@ -10863,10 +10940,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3698:6: ( 'ProtocolClass' )
+                    // InternalRoom.g:3724:6: ( 'ProtocolClass' )
                     {
-                    // InternalRoom.g:3698:6: ( 'ProtocolClass' )
-                    // InternalRoom.g:3699:1: 'ProtocolClass'
+                    // InternalRoom.g:3724:6: ( 'ProtocolClass' )
+                    // InternalRoom.g:3725:1: 'ProtocolClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getProtocolClassKeyword_3()); 
                     match(input,20,FOLLOW_2); 
@@ -10878,10 +10955,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3706:6: ( 'CompoundProtocolClass' )
+                    // InternalRoom.g:3732:6: ( 'CompoundProtocolClass' )
                     {
-                    // InternalRoom.g:3706:6: ( 'CompoundProtocolClass' )
-                    // InternalRoom.g:3707:1: 'CompoundProtocolClass'
+                    // InternalRoom.g:3732:6: ( 'CompoundProtocolClass' )
+                    // InternalRoom.g:3733:1: 'CompoundProtocolClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getCompoundProtocolClassKeyword_4()); 
                     match(input,21,FOLLOW_2); 
@@ -10893,10 +10970,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 6 :
-                    // InternalRoom.g:3714:6: ( 'SubSystemClass' )
+                    // InternalRoom.g:3740:6: ( 'SubSystemClass' )
                     {
-                    // InternalRoom.g:3714:6: ( 'SubSystemClass' )
-                    // InternalRoom.g:3715:1: 'SubSystemClass'
+                    // InternalRoom.g:3740:6: ( 'SubSystemClass' )
+                    // InternalRoom.g:3741:1: 'SubSystemClass'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getSubSystemClassKeyword_5()); 
                     match(input,22,FOLLOW_2); 
@@ -10908,10 +10985,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 7 :
-                    // InternalRoom.g:3722:6: ( 'LogicalSystem' )
+                    // InternalRoom.g:3748:6: ( 'LogicalSystem' )
                     {
-                    // InternalRoom.g:3722:6: ( 'LogicalSystem' )
-                    // InternalRoom.g:3723:1: 'LogicalSystem'
+                    // InternalRoom.g:3748:6: ( 'LogicalSystem' )
+                    // InternalRoom.g:3749:1: 'LogicalSystem'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getLogicalSystemKeyword_6()); 
                     match(input,23,FOLLOW_2); 
@@ -10923,10 +11000,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 8 :
-                    // InternalRoom.g:3730:6: ( 'Port' )
+                    // InternalRoom.g:3756:6: ( 'Port' )
                     {
-                    // InternalRoom.g:3730:6: ( 'Port' )
-                    // InternalRoom.g:3731:1: 'Port'
+                    // InternalRoom.g:3756:6: ( 'Port' )
+                    // InternalRoom.g:3757:1: 'Port'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getPortKeyword_7()); 
                     match(input,24,FOLLOW_2); 
@@ -10938,10 +11015,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 9 :
-                    // InternalRoom.g:3738:6: ( 'Message' )
+                    // InternalRoom.g:3764:6: ( 'Message' )
                     {
-                    // InternalRoom.g:3738:6: ( 'Message' )
-                    // InternalRoom.g:3739:1: 'Message'
+                    // InternalRoom.g:3764:6: ( 'Message' )
+                    // InternalRoom.g:3765:1: 'Message'
                     {
                      before(grammarAccess.getAnnotationTargetTypeAccess().getMessageKeyword_8()); 
                     match(input,25,FOLLOW_2); 
@@ -10970,13 +11047,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraphNode__Alternatives"
-    // InternalRoom.g:3751:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) );
+    // InternalRoom.g:3777: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:3781:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) )
             int alt23=3;
             switch ( input.LA(1) ) {
             case 95:
@@ -11007,10 +11084,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt23) {
                 case 1 :
-                    // InternalRoom.g:3756:1: ( ruleState )
+                    // InternalRoom.g:3782:1: ( ruleState )
                     {
-                    // InternalRoom.g:3756:1: ( ruleState )
-                    // InternalRoom.g:3757:1: ruleState
+                    // InternalRoom.g:3782:1: ( ruleState )
+                    // InternalRoom.g:3783:1: ruleState
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11026,10 +11103,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3762:6: ( ruleChoicePoint )
+                    // InternalRoom.g:3788:6: ( ruleChoicePoint )
                     {
-                    // InternalRoom.g:3762:6: ( ruleChoicePoint )
-                    // InternalRoom.g:3763:1: ruleChoicePoint
+                    // InternalRoom.g:3788:6: ( ruleChoicePoint )
+                    // InternalRoom.g:3789:1: ruleChoicePoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11045,10 +11122,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3768:6: ( ruleTrPoint )
+                    // InternalRoom.g:3794:6: ( ruleTrPoint )
                     {
-                    // InternalRoom.g:3768:6: ( ruleTrPoint )
-                    // InternalRoom.g:3769:1: ruleTrPoint
+                    // InternalRoom.g:3794:6: ( ruleTrPoint )
+                    // InternalRoom.g:3795:1: ruleTrPoint
                     {
                      before(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11081,13 +11158,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:3806: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:3810: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 +11205,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt24) {
                 case 1 :
-                    // InternalRoom.g:3785:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalRoom.g:3811: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:3811:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) )
+                    // InternalRoom.g:3812: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:3813:1: ( rule__StateGraph__StatesAssignment_2_0 )
+                    // InternalRoom.g:3813:2: rule__StateGraph__StatesAssignment_2_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__StatesAssignment_2_0();
@@ -11153,14 +11230,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3791:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalRoom.g:3817: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:3817:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) )
+                    // InternalRoom.g:3818: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:3819:1: ( rule__StateGraph__TrPointsAssignment_2_1 )
+                    // InternalRoom.g:3819:2: rule__StateGraph__TrPointsAssignment_2_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TrPointsAssignment_2_1();
@@ -11178,14 +11255,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3797:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalRoom.g:3823: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:3823:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) )
+                    // InternalRoom.g:3824: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:3825:1: ( rule__StateGraph__ChPointsAssignment_2_2 )
+                    // InternalRoom.g:3825:2: rule__StateGraph__ChPointsAssignment_2_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__ChPointsAssignment_2_2();
@@ -11203,14 +11280,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3803:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalRoom.g:3829: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:3829:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) )
+                    // InternalRoom.g:3830: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:3831:1: ( rule__StateGraph__TransitionsAssignment_2_3 )
+                    // InternalRoom.g:3831:2: rule__StateGraph__TransitionsAssignment_2_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__TransitionsAssignment_2_3();
@@ -11228,14 +11305,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3809:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalRoom.g:3835: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:3835:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) )
+                    // InternalRoom.g:3836: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:3837:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 )
+                    // InternalRoom.g:3837:2: rule__StateGraph__RefinedTransitionsAssignment_2_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateGraph__RefinedTransitionsAssignment_2_4();
@@ -11270,13 +11347,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:3846: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:3850: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 +11394,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt25) {
                 case 1 :
-                    // InternalRoom.g:3825:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalRoom.g:3851: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:3851:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) )
+                    // InternalRoom.g:3852: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:3853:1: ( rule__StateMachine__StatesAssignment_3_0 )
+                    // InternalRoom.g:3853:2: rule__StateMachine__StatesAssignment_3_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__StatesAssignment_3_0();
@@ -11342,14 +11419,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3831:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalRoom.g:3857: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:3857:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) )
+                    // InternalRoom.g:3858: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:3859:1: ( rule__StateMachine__TrPointsAssignment_3_1 )
+                    // InternalRoom.g:3859:2: rule__StateMachine__TrPointsAssignment_3_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TrPointsAssignment_3_1();
@@ -11367,14 +11444,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3837:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalRoom.g:3863: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:3863:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) )
+                    // InternalRoom.g:3864: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:3865:1: ( rule__StateMachine__ChPointsAssignment_3_2 )
+                    // InternalRoom.g:3865:2: rule__StateMachine__ChPointsAssignment_3_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__ChPointsAssignment_3_2();
@@ -11392,14 +11469,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:3843:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalRoom.g:3869: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:3869:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) )
+                    // InternalRoom.g:3870: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:3871:1: ( rule__StateMachine__TransitionsAssignment_3_3 )
+                    // InternalRoom.g:3871:2: rule__StateMachine__TransitionsAssignment_3_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__TransitionsAssignment_3_3();
@@ -11417,14 +11494,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 5 :
-                    // InternalRoom.g:3849:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalRoom.g:3875: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:3875:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) )
+                    // InternalRoom.g:3876: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:3877:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 )
+                    // InternalRoom.g:3877:2: rule__StateMachine__RefinedTransitionsAssignment_3_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__StateMachine__RefinedTransitionsAssignment_3_4();
@@ -11459,13 +11536,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__State__Alternatives"
-    // InternalRoom.g:3860:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) );
+    // InternalRoom.g:3886: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:3890:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) )
             int alt26=2;
             int LA26_0 = input.LA(1);
 
@@ -11483,10 +11560,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt26) {
                 case 1 :
-                    // InternalRoom.g:3865:1: ( ruleSimpleState )
+                    // InternalRoom.g:3891:1: ( ruleSimpleState )
                     {
-                    // InternalRoom.g:3865:1: ( ruleSimpleState )
-                    // InternalRoom.g:3866:1: ruleSimpleState
+                    // InternalRoom.g:3891:1: ( ruleSimpleState )
+                    // InternalRoom.g:3892:1: ruleSimpleState
                     {
                      before(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11502,10 +11579,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3871:6: ( ruleRefinedState )
+                    // InternalRoom.g:3897:6: ( ruleRefinedState )
                     {
-                    // InternalRoom.g:3871:6: ( ruleRefinedState )
-                    // InternalRoom.g:3872:1: ruleRefinedState
+                    // InternalRoom.g:3897:6: ( ruleRefinedState )
+                    // InternalRoom.g:3898:1: ruleRefinedState
                     {
                      before(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11538,13 +11615,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:3908: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:3912:1: ( ( ( rule__DetailCode__Group_0__0 ) ) | ( ( rule__DetailCode__Group_1__0 ) ) )
             int alt27=2;
             int LA27_0 = input.LA(1);
 
@@ -11562,14 +11639,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             }
             switch (alt27) {
                 case 1 :
-                    // InternalRoom.g:3887:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalRoom.g:3913: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:3913:1: ( ( rule__DetailCode__Group_0__0 ) )
+                    // InternalRoom.g:3914: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:3915:1: ( rule__DetailCode__Group_0__0 )
+                    // InternalRoom.g:3915:2: rule__DetailCode__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_0__0();
@@ -11587,14 +11664,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3893:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalRoom.g:3919: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:3919:6: ( ( rule__DetailCode__Group_1__0 ) )
+                    // InternalRoom.g:3920: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:3921:1: ( rule__DetailCode__Group_1__0 )
+                    // InternalRoom.g:3921:2: rule__DetailCode__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__Group_1__0();
@@ -11629,13 +11706,13 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPoint__Alternatives"
-    // InternalRoom.g:3904:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) );
+    // InternalRoom.g:3930: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:3934:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) )
             int alt28=3;
             switch ( input.LA(1) ) {
             case 101:
@@ -11663,10 +11740,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
             switch (alt28) {
                 case 1 :
-                    // InternalRoom.g:3909:1: ( ruleTransitionPoint )
+                    // InternalRoom.g:3935:1: ( ruleTransitionPoint )
                     {
-                    // InternalRoom.g:3909:1: ( ruleTransitionPoint )
-                    // InternalRoom.g:3910:1: ruleTransitionPoint
+                    // InternalRoom.g:3935:1: ( ruleTransitionPoint )
+                    // InternalRoom.g:3936:1: ruleTransitionPoint
                     {
                      before(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11682,10 +11759,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3915:6: ( ruleEntryPoint )
+                    // InternalRoom.g:3941:6: ( ruleEntryPoint )
                     {
-                    // InternalRoom.g:3915:6: ( ruleEntryPoint )
-                    // InternalRoom.g:3916:1: ruleEntryPoint
+                    // InternalRoom.g:3941:6: ( ruleEntryPoint )
+                    // InternalRoom.g:3942:1: ruleEntryPoint
                     {
                      before(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11701,10 +11778,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3921:6: ( ruleExitPoint )
+                    // InternalRoom.g:3947:6: ( ruleExitPoint )
                     {
-                    // InternalRoom.g:3921:6: ( ruleExitPoint )
-                    // InternalRoom.g:3922:1: ruleExitPoint
+                    // InternalRoom.g:3947:6: ( ruleExitPoint )
+                    // InternalRoom.g:3948:1: ruleExitPoint
                     {
                      before(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11736,81 +11813,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:3958: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:3962: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:3963:1: ( ruleTransition )
+                    {
+                    // InternalRoom.g:3963:1: ( ruleTransition )
+                    // InternalRoom.g:3964:1: ruleTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
+                    pushFollow(FOLLOW_2);
+                    ruleTransition();
+
+                    state._fsp--;
 
-                if ( (LA29_1==RULE_ID) ) {
-                    int LA29_2 = input.LA(3);
+                     after(grammarAccess.getTransitionBaseAccess().getTransitionParserRuleCall_0()); 
 
-                    if ( (LA29_2==46) ) {
-                        int LA29_3 = input.LA(4);
+                    }
 
-                        if ( (LA29_3==106) ) {
-                            alt29=1;
+
+                    }
+                    break;
+                case 2 :
+                    // InternalRoom.g:3969:6: ( ruleRefinedTransition )
+                    {
+                    // InternalRoom.g:3969:6: ( ruleRefinedTransition )
+                    // InternalRoom.g:3970:1: ruleRefinedTransition
+                    {
+                     before(grammarAccess.getTransitionBaseAccess().getRefinedTransitionParserRuleCall_1()); 
+                    pushFollow(FOLLOW_2);
+                    ruleRefinedTransition();
+
+                    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:3980:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) );
+    public final void rule__Transition__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+            
+        try {
+            // InternalRoom.g:3984: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:3985:1: ( ruleInitialTransition )
                     {
-                    // InternalRoom.g:3938:1: ( ruleInitialTransition )
-                    // InternalRoom.g:3939:1: ruleInitialTransition
+                    // InternalRoom.g:3985:1: ( ruleInitialTransition )
+                    // InternalRoom.g:3986:1: ruleInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11826,10 +11982,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3944:6: ( ruleNonInitialTransition )
+                    // InternalRoom.g:3991:6: ( ruleNonInitialTransition )
                     {
-                    // InternalRoom.g:3944:6: ( ruleNonInitialTransition )
-                    // InternalRoom.g:3945:1: ruleNonInitialTransition
+                    // InternalRoom.g:3991:6: ( ruleNonInitialTransition )
+                    // InternalRoom.g:3992:1: ruleNonInitialTransition
                     {
                      before(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11862,21 +12018,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NonInitialTransition__Alternatives"
-    // InternalRoom.g:3955:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );
+    // InternalRoom.g:4002: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:4006:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) )
+            int alt31=3;
+            alt31 = dfa31.predict(input);
+            switch (alt31) {
                 case 1 :
-                    // InternalRoom.g:3960:1: ( ruleTransitionChainStartTransition )
+                    // InternalRoom.g:4007:1: ( ruleTransitionChainStartTransition )
                     {
-                    // InternalRoom.g:3960:1: ( ruleTransitionChainStartTransition )
-                    // InternalRoom.g:3961:1: ruleTransitionChainStartTransition
+                    // InternalRoom.g:4007:1: ( ruleTransitionChainStartTransition )
+                    // InternalRoom.g:4008:1: ruleTransitionChainStartTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11892,10 +12048,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3966:6: ( ruleContinuationTransition )
+                    // InternalRoom.g:4013:6: ( ruleContinuationTransition )
                     {
-                    // InternalRoom.g:3966:6: ( ruleContinuationTransition )
-                    // InternalRoom.g:3967:1: ruleContinuationTransition
+                    // InternalRoom.g:4013:6: ( ruleContinuationTransition )
+                    // InternalRoom.g:4014:1: ruleContinuationTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -11911,10 +12067,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:3972:6: ( ruleCPBranchTransition )
+                    // InternalRoom.g:4019:6: ( ruleCPBranchTransition )
                     {
-                    // InternalRoom.g:3972:6: ( ruleCPBranchTransition )
-                    // InternalRoom.g:3973:1: ruleCPBranchTransition
+                    // InternalRoom.g:4019:6: ( ruleCPBranchTransition )
+                    // InternalRoom.g:4020:1: ruleCPBranchTransition
                     {
                      before(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -11947,21 +12103,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionChainStartTransition__Alternatives"
-    // InternalRoom.g:3983:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );
+    // InternalRoom.g:4030: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:4034:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) )
+            int alt32=2;
+            alt32 = dfa32.predict(input);
+            switch (alt32) {
                 case 1 :
-                    // InternalRoom.g:3988:1: ( ruleTriggeredTransition )
+                    // InternalRoom.g:4035:1: ( ruleTriggeredTransition )
                     {
-                    // InternalRoom.g:3988:1: ( ruleTriggeredTransition )
-                    // InternalRoom.g:3989:1: ruleTriggeredTransition
+                    // InternalRoom.g:4035:1: ( ruleTriggeredTransition )
+                    // InternalRoom.g:4036:1: ruleTriggeredTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -11977,10 +12133,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:3994:6: ( ruleGuardedTransition )
+                    // InternalRoom.g:4041:6: ( ruleGuardedTransition )
                     {
-                    // InternalRoom.g:3994:6: ( ruleGuardedTransition )
-                    // InternalRoom.g:3995:1: ruleGuardedTransition
+                    // InternalRoom.g:4041:6: ( ruleGuardedTransition )
+                    // InternalRoom.g:4042:1: ruleGuardedTransition
                     {
                      before(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12013,28 +12169,28 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionTerminal__Alternatives"
-    // InternalRoom.g:4005:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) );
+    // InternalRoom.g:4052: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:4056: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==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 if ( (LA32_1==53) ) {
-                    alt32=3;
+                else if ( (LA33_1==53) ) {
+                    alt33=3;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 32, 1, input);
+                        new NoViableAltException("", 33, 1, input);
 
                     throw nvae;
                 }
@@ -12042,27 +12198,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:4057:1: ( ruleStateTerminal )
                     {
-                    // InternalRoom.g:4010:1: ( ruleStateTerminal )
-                    // InternalRoom.g:4011:1: ruleStateTerminal
+                    // InternalRoom.g:4057:1: ( ruleStateTerminal )
+                    // InternalRoom.g:4058:1: ruleStateTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12078,10 +12234,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4016:6: ( ruleTrPointTerminal )
+                    // InternalRoom.g:4063:6: ( ruleTrPointTerminal )
                     {
-                    // InternalRoom.g:4016:6: ( ruleTrPointTerminal )
-                    // InternalRoom.g:4017:1: ruleTrPointTerminal
+                    // InternalRoom.g:4063:6: ( ruleTrPointTerminal )
+                    // InternalRoom.g:4064:1: ruleTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12097,10 +12253,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4022:6: ( ruleSubStateTrPointTerminal )
+                    // InternalRoom.g:4069:6: ( ruleSubStateTrPointTerminal )
                     {
-                    // InternalRoom.g:4022:6: ( ruleSubStateTrPointTerminal )
-                    // InternalRoom.g:4023:1: ruleSubStateTrPointTerminal
+                    // InternalRoom.g:4069:6: ( ruleSubStateTrPointTerminal )
+                    // InternalRoom.g:4070:1: ruleSubStateTrPointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -12116,10 +12272,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4028:6: ( ruleChoicepointTerminal )
+                    // InternalRoom.g:4075:6: ( ruleChoicepointTerminal )
                     {
-                    // InternalRoom.g:4028:6: ( ruleChoicepointTerminal )
-                    // InternalRoom.g:4029:1: ruleChoicepointTerminal
+                    // InternalRoom.g:4075:6: ( ruleChoicepointTerminal )
+                    // InternalRoom.g:4076:1: ruleChoicepointTerminal
                     {
                      before(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
                     pushFollow(FOLLOW_2);
@@ -12152,34 +12308,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SemanticsRule__Alternatives"
-    // InternalRoom.g:4039:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) );
+    // InternalRoom.g:4086: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:4090: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:4091:1: ( ruleInSemanticsRule )
                     {
-                    // InternalRoom.g:4044:1: ( ruleInSemanticsRule )
-                    // InternalRoom.g:4045:1: ruleInSemanticsRule
+                    // InternalRoom.g:4091:1: ( ruleInSemanticsRule )
+                    // InternalRoom.g:4092:1: ruleInSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12195,10 +12351,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4050:6: ( ruleOutSemanticsRule )
+                    // InternalRoom.g:4097:6: ( ruleOutSemanticsRule )
                     {
-                    // InternalRoom.g:4050:6: ( ruleOutSemanticsRule )
-                    // InternalRoom.g:4051:1: ruleOutSemanticsRule
+                    // InternalRoom.g:4097:6: ( ruleOutSemanticsRule )
+                    // InternalRoom.g:4098:1: ruleOutSemanticsRule
                     {
                      before(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12231,38 +12387,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:4108: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:4112: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:4113: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:4113:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4114: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:4115:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4115:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -12280,14 +12436,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4072:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4119: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:4119:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4120: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:4121:1: ( rule__InSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4121:2: rule__InSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3_1_1__0();
@@ -12322,38 +12478,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:4130: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:4134: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:4135: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:4135:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) )
+                    // InternalRoom.g:4136: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:4137:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 )
+                    // InternalRoom.g:4137:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__FollowUpsAssignment_3_1_0();
@@ -12371,14 +12527,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4094:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4141: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:4141:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) )
+                    // InternalRoom.g:4142: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:4143:1: ( rule__OutSemanticsRule__Group_3_1_1__0 )
+                    // InternalRoom.g:4143:2: rule__OutSemanticsRule__Group_3_1_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3_1_1__0();
@@ -12413,38 +12569,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:4152: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:4156: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:4157: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:4157:1: ( ( rule__AnnotationType__TargetsAssignment_6_0 ) )
+                    // InternalRoom.g:4158: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:4159:1: ( rule__AnnotationType__TargetsAssignment_6_0 )
+                    // InternalRoom.g:4159:2: rule__AnnotationType__TargetsAssignment_6_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__TargetsAssignment_6_0();
@@ -12462,14 +12618,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4116:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
+                    // InternalRoom.g:4163: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:4163:6: ( ( rule__AnnotationType__Group_6_1__0 ) )
+                    // InternalRoom.g:4164: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:4165:1: ( rule__AnnotationType__Group_6_1__0 )
+                    // InternalRoom.g:4165:2: rule__AnnotationType__Group_6_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__Group_6_1__0();
@@ -12504,120 +12660,120 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationAttribute__Alternatives"
-    // InternalRoom.g:4127:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) );
+    // InternalRoom.g:4174: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:4178: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:4179:1: ( ruleSimpleAnnotationAttribute )
                     {
-                    // InternalRoom.g:4132:1: ( ruleSimpleAnnotationAttribute )
-                    // InternalRoom.g:4133:1: ruleSimpleAnnotationAttribute
+                    // InternalRoom.g:4179:1: ( ruleSimpleAnnotationAttribute )
+                    // InternalRoom.g:4180:1: ruleSimpleAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12633,10 +12789,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4138:6: ( ruleEnumAnnotationAttribute )
+                    // InternalRoom.g:4185:6: ( ruleEnumAnnotationAttribute )
                     {
-                    // InternalRoom.g:4138:6: ( ruleEnumAnnotationAttribute )
-                    // InternalRoom.g:4139:1: ruleEnumAnnotationAttribute
+                    // InternalRoom.g:4185:6: ( ruleEnumAnnotationAttribute )
+                    // InternalRoom.g:4186:1: ruleEnumAnnotationAttribute
                     {
                      before(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12669,38 +12825,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:4196: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:4200: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:4201: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:4201:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4202: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:4203:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4203:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleAnnotationAttribute__OptionalAssignment_0_0();
@@ -12718,10 +12874,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4160:6: ( 'mandatory' )
+                    // InternalRoom.g:4207:6: ( 'mandatory' )
                     {
-                    // InternalRoom.g:4160:6: ( 'mandatory' )
-                    // InternalRoom.g:4161:1: 'mandatory'
+                    // InternalRoom.g:4207:6: ( 'mandatory' )
+                    // InternalRoom.g:4208:1: 'mandatory'
                     {
                      before(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,26,FOLLOW_2); 
@@ -12750,38 +12906,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:4220: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:4224: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:4225: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:4225:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) )
+                    // InternalRoom.g:4226: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:4227:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 )
+                    // InternalRoom.g:4227:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumAnnotationAttribute__OptionalAssignment_0_0();
@@ -12799,10 +12955,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4184:6: ( 'mandatory' )
+                    // InternalRoom.g:4231:6: ( 'mandatory' )
                     {
-                    // InternalRoom.g:4184:6: ( 'mandatory' )
-                    // InternalRoom.g:4185:1: 'mandatory'
+                    // InternalRoom.g:4231:6: ( 'mandatory' )
+                    // InternalRoom.g:4232:1: 'mandatory'
                     {
                      before(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); 
                     match(input,26,FOLLOW_2); 
@@ -12831,38 +12987,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:4244: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:4248: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:4249: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:4249:1: ( ( rule__Import__Group_1_0__0 ) )
+                    // InternalRoom.g:4250: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:4251:1: ( rule__Import__Group_1_0__0 )
+                    // InternalRoom.g:4251:2: rule__Import__Group_1_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Import__Group_1_0__0();
@@ -12880,10 +13036,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4208:6: ( 'model' )
+                    // InternalRoom.g:4255:6: ( 'model' )
                     {
-                    // InternalRoom.g:4208:6: ( 'model' )
-                    // InternalRoom.g:4209:1: 'model'
+                    // InternalRoom.g:4255:6: ( 'model' )
+                    // InternalRoom.g:4256:1: 'model'
                     {
                      before(grammarAccess.getImportAccess().getModelKeyword_1_1()); 
                     match(input,27,FOLLOW_2); 
@@ -12912,19 +13068,19 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Literal__Alternatives"
-    // InternalRoom.g:4222:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) );
+    // InternalRoom.g:4269: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:4273: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 +13088,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:4274:1: ( ruleBooleanLiteral )
                     {
-                    // InternalRoom.g:4227:1: ( ruleBooleanLiteral )
-                    // InternalRoom.g:4228:1: ruleBooleanLiteral
+                    // InternalRoom.g:4274:1: ( ruleBooleanLiteral )
+                    // InternalRoom.g:4275:1: ruleBooleanLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -12968,10 +13124,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4233:6: ( ruleNumberLiteral )
+                    // InternalRoom.g:4280:6: ( ruleNumberLiteral )
                     {
-                    // InternalRoom.g:4233:6: ( ruleNumberLiteral )
-                    // InternalRoom.g:4234:1: ruleNumberLiteral
+                    // InternalRoom.g:4280:6: ( ruleNumberLiteral )
+                    // InternalRoom.g:4281:1: ruleNumberLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -12987,10 +13143,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4239:6: ( ruleStringLiteral )
+                    // InternalRoom.g:4286:6: ( ruleStringLiteral )
                     {
-                    // InternalRoom.g:4239:6: ( ruleStringLiteral )
-                    // InternalRoom.g:4240:1: ruleStringLiteral
+                    // InternalRoom.g:4286:6: ( ruleStringLiteral )
+                    // InternalRoom.g:4287:1: ruleStringLiteral
                     {
                      before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
                     pushFollow(FOLLOW_2);
@@ -13023,34 +13179,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:4297: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:4301: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:4302:1: ( 'false' )
                     {
-                    // InternalRoom.g:4255:1: ( 'false' )
-                    // InternalRoom.g:4256:1: 'false'
+                    // InternalRoom.g:4302:1: ( 'false' )
+                    // InternalRoom.g:4303:1: 'false'
                     {
                      before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); 
                     match(input,28,FOLLOW_2); 
@@ -13062,14 +13218,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4263:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalRoom.g:4310: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:4310:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalRoom.g:4311: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:4312:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalRoom.g:4312:2: rule__BooleanLiteral__IsTrueAssignment_1_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__BooleanLiteral__IsTrueAssignment_1_1();
@@ -13104,38 +13260,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__NumberLiteral__Alternatives"
-    // InternalRoom.g:4274:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) );
+    // InternalRoom.g:4321: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:4325: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 +13299,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 +13327,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 +13345,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:4326:1: ( ruleIntLiteral )
                     {
-                    // InternalRoom.g:4279:1: ( ruleIntLiteral )
-                    // InternalRoom.g:4280:1: ruleIntLiteral
+                    // InternalRoom.g:4326:1: ( ruleIntLiteral )
+                    // InternalRoom.g:4327:1: ruleIntLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -13220,10 +13376,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4285:6: ( ruleRealLiteral )
+                    // InternalRoom.g:4332:6: ( ruleRealLiteral )
                     {
-                    // InternalRoom.g:4285:6: ( ruleRealLiteral )
-                    // InternalRoom.g:4286:1: ruleRealLiteral
+                    // InternalRoom.g:4332:6: ( ruleRealLiteral )
+                    // InternalRoom.g:4333:1: ruleRealLiteral
                     {
                      before(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -13256,38 +13412,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:4343: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:4347: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:4348: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:4348:1: ( ( rule__Integer__Group_0__0 ) )
+                    // InternalRoom.g:4349: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:4350:1: ( rule__Integer__Group_0__0 )
+                    // InternalRoom.g:4350:2: rule__Integer__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Group_0__0();
@@ -13305,10 +13461,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4307:6: ( RULE_HEX )
+                    // InternalRoom.g:4354:6: ( RULE_HEX )
                     {
-                    // InternalRoom.g:4307:6: ( RULE_HEX )
-                    // InternalRoom.g:4308:1: RULE_HEX
+                    // InternalRoom.g:4354:6: ( RULE_HEX )
+                    // InternalRoom.g:4355:1: RULE_HEX
                     {
                      before(grammarAccess.getIntegerAccess().getHEXTerminalRuleCall_1()); 
                     match(input,RULE_HEX,FOLLOW_2); 
@@ -13337,34 +13493,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Integer__Alternatives_0_0"
-    // InternalRoom.g:4318:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4365: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:4369: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:4370:1: ( '+' )
                     {
-                    // InternalRoom.g:4323:1: ( '+' )
-                    // InternalRoom.g:4324:1: '+'
+                    // InternalRoom.g:4370:1: ( '+' )
+                    // InternalRoom.g:4371:1: '+'
                     {
                      before(grammarAccess.getIntegerAccess().getPlusSignKeyword_0_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13376,10 +13532,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4331:6: ( '-' )
+                    // InternalRoom.g:4378:6: ( '-' )
                     {
-                    // InternalRoom.g:4331:6: ( '-' )
-                    // InternalRoom.g:4332:1: '-'
+                    // InternalRoom.g:4378:6: ( '-' )
+                    // InternalRoom.g:4379:1: '-'
                     {
                      before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13408,58 +13564,58 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Real__Alternatives"
-    // InternalRoom.g:4344:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) );
+    // InternalRoom.g:4391: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:4395: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 +13623,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 +13671,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 +13709,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:4396:1: ( ruleDecimal )
                     {
-                    // InternalRoom.g:4349:1: ( ruleDecimal )
-                    // InternalRoom.g:4350:1: ruleDecimal
+                    // InternalRoom.g:4396:1: ( ruleDecimal )
+                    // InternalRoom.g:4397:1: ruleDecimal
                     {
                      before(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
                     pushFollow(FOLLOW_2);
@@ -13579,10 +13735,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4355:6: ( ruleDecimalExp )
+                    // InternalRoom.g:4402:6: ( ruleDecimalExp )
                     {
-                    // InternalRoom.g:4355:6: ( ruleDecimalExp )
-                    // InternalRoom.g:4356:1: ruleDecimalExp
+                    // InternalRoom.g:4402:6: ( ruleDecimalExp )
+                    // InternalRoom.g:4403:1: ruleDecimalExp
                     {
                      before(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
                     pushFollow(FOLLOW_2);
@@ -13615,34 +13771,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Alternatives_0"
-    // InternalRoom.g:4366:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4413: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:4417: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:4418:1: ( '+' )
                     {
-                    // InternalRoom.g:4371:1: ( '+' )
-                    // InternalRoom.g:4372:1: '+'
+                    // InternalRoom.g:4418:1: ( '+' )
+                    // InternalRoom.g:4419:1: '+'
                     {
                      before(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13654,10 +13810,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4379:6: ( '-' )
+                    // InternalRoom.g:4426:6: ( '-' )
                     {
-                    // InternalRoom.g:4379:6: ( '-' )
-                    // InternalRoom.g:4380:1: '-'
+                    // InternalRoom.g:4426:6: ( '-' )
+                    // InternalRoom.g:4427:1: '-'
                     {
                      before(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13686,34 +13842,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_0"
-    // InternalRoom.g:4392:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4439: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:4443: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:4444:1: ( '+' )
                     {
-                    // InternalRoom.g:4397:1: ( '+' )
-                    // InternalRoom.g:4398:1: '+'
+                    // InternalRoom.g:4444:1: ( '+' )
+                    // InternalRoom.g:4445:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13725,10 +13881,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4405:6: ( '-' )
+                    // InternalRoom.g:4452:6: ( '-' )
                     {
-                    // InternalRoom.g:4405:6: ( '-' )
-                    // InternalRoom.g:4406:1: '-'
+                    // InternalRoom.g:4452:6: ( '-' )
+                    // InternalRoom.g:4453:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13757,34 +13913,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_4"
-    // InternalRoom.g:4418:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) );
+    // InternalRoom.g:4465: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:4469: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:4470:1: ( 'e' )
                     {
-                    // InternalRoom.g:4423:1: ( 'e' )
-                    // InternalRoom.g:4424:1: 'e'
+                    // InternalRoom.g:4470:1: ( 'e' )
+                    // InternalRoom.g:4471:1: 'e'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); 
                     match(input,31,FOLLOW_2); 
@@ -13796,10 +13952,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4431:6: ( 'E' )
+                    // InternalRoom.g:4478:6: ( 'E' )
                     {
-                    // InternalRoom.g:4431:6: ( 'E' )
-                    // InternalRoom.g:4432:1: 'E'
+                    // InternalRoom.g:4478:6: ( 'E' )
+                    // InternalRoom.g:4479:1: 'E'
                     {
                      before(grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); 
                     match(input,32,FOLLOW_2); 
@@ -13828,34 +13984,34 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Alternatives_5"
-    // InternalRoom.g:4444:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) );
+    // InternalRoom.g:4491: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:4495: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:4496:1: ( '+' )
                     {
-                    // InternalRoom.g:4449:1: ( '+' )
-                    // InternalRoom.g:4450:1: '+'
+                    // InternalRoom.g:4496:1: ( '+' )
+                    // InternalRoom.g:4497:1: '+'
                     {
                      before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_5_0()); 
                     match(input,29,FOLLOW_2); 
@@ -13867,10 +14023,10 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4457:6: ( '-' )
+                    // InternalRoom.g:4504:6: ( '-' )
                     {
-                    // InternalRoom.g:4457:6: ( '-' )
-                    // InternalRoom.g:4458:1: '-'
+                    // InternalRoom.g:4504:6: ( '-' )
+                    // InternalRoom.g:4505:1: '-'
                     {
                      before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_5_1()); 
                     match(input,30,FOLLOW_2); 
@@ -13899,47 +14055,47 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CommunicationType__Alternatives"
-    // InternalRoom.g:4470:1: rule__CommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'sync' ) ) );
+    // InternalRoom.g:4517: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:4521: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:4522:1: ( ( 'eventdriven' ) )
                     {
-                    // InternalRoom.g:4475:1: ( ( 'eventdriven' ) )
-                    // InternalRoom.g:4476:1: ( 'eventdriven' )
+                    // InternalRoom.g:4522:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4523:1: ( 'eventdriven' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4477:1: ( 'eventdriven' )
-                    // InternalRoom.g:4477:3: 'eventdriven'
+                    // InternalRoom.g:4524:1: ( 'eventdriven' )
+                    // InternalRoom.g:4524:3: 'eventdriven'
                     {
                     match(input,33,FOLLOW_2); 
 
@@ -13953,14 +14109,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4482:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4529:6: ( ( 'datadriven' ) )
                     {
-                    // InternalRoom.g:4482:6: ( ( 'datadriven' ) )
-                    // InternalRoom.g:4483:1: ( 'datadriven' )
+                    // InternalRoom.g:4529:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4530:1: ( 'datadriven' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4484:1: ( 'datadriven' )
-                    // InternalRoom.g:4484:3: 'datadriven'
+                    // InternalRoom.g:4531:1: ( 'datadriven' )
+                    // InternalRoom.g:4531:3: 'datadriven'
                     {
                     match(input,34,FOLLOW_2); 
 
@@ -13974,14 +14130,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4489:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4536:6: ( ( 'sync' ) )
                     {
-                    // InternalRoom.g:4489:6: ( ( 'sync' ) )
-                    // InternalRoom.g:4490:1: ( 'sync' )
+                    // InternalRoom.g:4536:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4537:1: ( 'sync' )
                     {
                      before(grammarAccess.getCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4491:1: ( 'sync' )
-                    // InternalRoom.g:4491:3: 'sync'
+                    // InternalRoom.g:4538:1: ( 'sync' )
+                    // InternalRoom.g:4538:3: 'sync'
                     {
                     match(input,35,FOLLOW_2); 
 
@@ -14012,38 +14168,38 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ReferenceType__Alternatives"
-    // InternalRoom.g:4501:1: rule__ReferenceType__Alternatives : ( ( ( 'fixed' ) ) | ( ( 'optional' ) ) );
+    // InternalRoom.g:4548: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:4552: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:4553:1: ( ( 'fixed' ) )
                     {
-                    // InternalRoom.g:4506:1: ( ( 'fixed' ) )
-                    // InternalRoom.g:4507:1: ( 'fixed' )
+                    // InternalRoom.g:4553:1: ( ( 'fixed' ) )
+                    // InternalRoom.g:4554:1: ( 'fixed' )
                     {
                      before(grammarAccess.getReferenceTypeAccess().getFIXEDEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4508:1: ( 'fixed' )
-                    // InternalRoom.g:4508:3: 'fixed'
+                    // InternalRoom.g:4555:1: ( 'fixed' )
+                    // InternalRoom.g:4555:3: 'fixed'
                     {
                     match(input,36,FOLLOW_2); 
 
@@ -14057,14 +14213,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4513:6: ( ( 'optional' ) )
+                    // InternalRoom.g:4560:6: ( ( 'optional' ) )
                     {
-                    // InternalRoom.g:4513:6: ( ( 'optional' ) )
-                    // InternalRoom.g:4514:1: ( 'optional' )
+                    // InternalRoom.g:4560:6: ( ( 'optional' ) )
+                    // InternalRoom.g:4561:1: ( 'optional' )
                     {
                      before(grammarAccess.getReferenceTypeAccess().getOPTIONALEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4515:1: ( 'optional' )
-                    // InternalRoom.g:4515:3: 'optional'
+                    // InternalRoom.g:4562:1: ( 'optional' )
+                    // InternalRoom.g:4562:3: 'optional'
                     {
                     match(input,37,FOLLOW_2); 
 
@@ -14095,52 +14251,52 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ComponentCommunicationType__Alternatives"
-    // InternalRoom.g:4526:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) );
+    // InternalRoom.g:4573: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:4577: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:4578:1: ( ( 'eventdriven' ) )
                     {
-                    // InternalRoom.g:4531:1: ( ( 'eventdriven' ) )
-                    // InternalRoom.g:4532:1: ( 'eventdriven' )
+                    // InternalRoom.g:4578:1: ( ( 'eventdriven' ) )
+                    // InternalRoom.g:4579:1: ( 'eventdriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4533:1: ( 'eventdriven' )
-                    // InternalRoom.g:4533:3: 'eventdriven'
+                    // InternalRoom.g:4580:1: ( 'eventdriven' )
+                    // InternalRoom.g:4580:3: 'eventdriven'
                     {
                     match(input,33,FOLLOW_2); 
 
@@ -14154,14 +14310,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4538:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4585:6: ( ( 'datadriven' ) )
                     {
-                    // InternalRoom.g:4538:6: ( ( 'datadriven' ) )
-                    // InternalRoom.g:4539:1: ( 'datadriven' )
+                    // InternalRoom.g:4585:6: ( ( 'datadriven' ) )
+                    // InternalRoom.g:4586:1: ( 'datadriven' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4540:1: ( 'datadriven' )
-                    // InternalRoom.g:4540:3: 'datadriven'
+                    // InternalRoom.g:4587:1: ( 'datadriven' )
+                    // InternalRoom.g:4587:3: 'datadriven'
                     {
                     match(input,34,FOLLOW_2); 
 
@@ -14175,14 +14331,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4545:6: ( ( 'async' ) )
+                    // InternalRoom.g:4592:6: ( ( 'async' ) )
                     {
-                    // InternalRoom.g:4545:6: ( ( 'async' ) )
-                    // InternalRoom.g:4546:1: ( 'async' )
+                    // InternalRoom.g:4592:6: ( ( 'async' ) )
+                    // InternalRoom.g:4593:1: ( 'async' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4547:1: ( 'async' )
-                    // InternalRoom.g:4547:3: 'async'
+                    // InternalRoom.g:4594:1: ( 'async' )
+                    // InternalRoom.g:4594:3: 'async'
                     {
                     match(input,38,FOLLOW_2); 
 
@@ -14196,14 +14352,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4552:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4599:6: ( ( 'sync' ) )
                     {
-                    // InternalRoom.g:4552:6: ( ( 'sync' ) )
-                    // InternalRoom.g:4553:1: ( 'sync' )
+                    // InternalRoom.g:4599:6: ( ( 'sync' ) )
+                    // InternalRoom.g:4600:1: ( 'sync' )
                     {
                      before(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); 
-                    // InternalRoom.g:4554:1: ( 'sync' )
-                    // InternalRoom.g:4554:3: 'sync'
+                    // InternalRoom.g:4601:1: ( 'sync' )
+                    // InternalRoom.g:4601:3: 'sync'
                     {
                     match(input,35,FOLLOW_2); 
 
@@ -14234,52 +14390,52 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LiteralType__Alternatives"
-    // InternalRoom.g:4564:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) );
+    // InternalRoom.g:4611: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:4615: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:4616:1: ( ( 'ptBoolean' ) )
                     {
-                    // InternalRoom.g:4569:1: ( ( 'ptBoolean' ) )
-                    // InternalRoom.g:4570:1: ( 'ptBoolean' )
+                    // InternalRoom.g:4616:1: ( ( 'ptBoolean' ) )
+                    // InternalRoom.g:4617:1: ( 'ptBoolean' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); 
-                    // InternalRoom.g:4571:1: ( 'ptBoolean' )
-                    // InternalRoom.g:4571:3: 'ptBoolean'
+                    // InternalRoom.g:4618:1: ( 'ptBoolean' )
+                    // InternalRoom.g:4618:3: 'ptBoolean'
                     {
                     match(input,39,FOLLOW_2); 
 
@@ -14293,14 +14449,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:4576:6: ( ( 'ptInteger' ) )
+                    // InternalRoom.g:4623:6: ( ( 'ptInteger' ) )
                     {
-                    // InternalRoom.g:4576:6: ( ( 'ptInteger' ) )
-                    // InternalRoom.g:4577:1: ( 'ptInteger' )
+                    // InternalRoom.g:4623:6: ( ( 'ptInteger' ) )
+                    // InternalRoom.g:4624:1: ( 'ptInteger' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); 
-                    // InternalRoom.g:4578:1: ( 'ptInteger' )
-                    // InternalRoom.g:4578:3: 'ptInteger'
+                    // InternalRoom.g:4625:1: ( 'ptInteger' )
+                    // InternalRoom.g:4625:3: 'ptInteger'
                     {
                     match(input,40,FOLLOW_2); 
 
@@ -14314,14 +14470,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:4583:6: ( ( 'ptReal' ) )
+                    // InternalRoom.g:4630:6: ( ( 'ptReal' ) )
                     {
-                    // InternalRoom.g:4583:6: ( ( 'ptReal' ) )
-                    // InternalRoom.g:4584:1: ( 'ptReal' )
+                    // InternalRoom.g:4630:6: ( ( 'ptReal' ) )
+                    // InternalRoom.g:4631:1: ( 'ptReal' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); 
-                    // InternalRoom.g:4585:1: ( 'ptReal' )
-                    // InternalRoom.g:4585:3: 'ptReal'
+                    // InternalRoom.g:4632:1: ( 'ptReal' )
+                    // InternalRoom.g:4632:3: 'ptReal'
                     {
                     match(input,41,FOLLOW_2); 
 
@@ -14335,14 +14491,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:4590:6: ( ( 'ptCharacter' ) )
+                    // InternalRoom.g:4637:6: ( ( 'ptCharacter' ) )
                     {
-                    // InternalRoom.g:4590:6: ( ( 'ptCharacter' ) )
-                    // InternalRoom.g:4591:1: ( 'ptCharacter' )
+                    // InternalRoom.g:4637:6: ( ( 'ptCharacter' ) )
+                    // InternalRoom.g:4638:1: ( 'ptCharacter' )
                     {
                      before(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); 
-                    // InternalRoom.g:4592:1: ( 'ptCharacter' )
-                    // InternalRoom.g:4592:3: 'ptCharacter'
+                    // InternalRoom.g:4639:1: ( 'ptCharacter' )
+                    // InternalRoom.g:4639:3: 'ptCharacter'
                     {
                     match(input,42,FOLLOW_2); 
 
@@ -14373,14 +14529,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:4651: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:4655:1: ( rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1 )
+            // InternalRoom.g:4656:2: rule__RoomModel__Group__0__Impl rule__RoomModel__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RoomModel__Group__0__Impl();
@@ -14411,17 +14567,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:4663: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:4667:1: ( ( 'RoomModel' ) )
+            // InternalRoom.g:4668:1: ( 'RoomModel' )
             {
-            // InternalRoom.g:4621:1: ( 'RoomModel' )
-            // InternalRoom.g:4622:1: 'RoomModel'
+            // InternalRoom.g:4668:1: ( 'RoomModel' )
+            // InternalRoom.g:4669:1: 'RoomModel'
             {
              before(grammarAccess.getRoomModelAccess().getRoomModelKeyword_0()); 
             match(input,43,FOLLOW_2); 
@@ -14448,14 +14604,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:4682: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:4686:1: ( rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2 )
+            // InternalRoom.g:4687:2: rule__RoomModel__Group__1__Impl rule__RoomModel__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RoomModel__Group__1__Impl();
@@ -14486,21 +14642,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:4694: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:4698:1: ( ( ( rule__RoomModel__NameAssignment_1 ) ) )
+            // InternalRoom.g:4699:1: ( ( rule__RoomModel__NameAssignment_1 ) )
             {
-            // InternalRoom.g:4652:1: ( ( rule__RoomModel__NameAssignment_1 ) )
-            // InternalRoom.g:4653:1: ( rule__RoomModel__NameAssignment_1 )
+            // InternalRoom.g:4699:1: ( ( rule__RoomModel__NameAssignment_1 ) )
+            // InternalRoom.g:4700: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:4701:1: ( rule__RoomModel__NameAssignment_1 )
+            // InternalRoom.g:4701:2: rule__RoomModel__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RoomModel__NameAssignment_1();
@@ -14533,14 +14689,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:4711: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:4715:1: ( rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3 )
+            // InternalRoom.g:4716:2: rule__RoomModel__Group__2__Impl rule__RoomModel__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RoomModel__Group__2__Impl();
@@ -14571,29 +14727,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:4723: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:4727:1: ( ( ( rule__RoomModel__DocuAssignment_2 )? ) )
+            // InternalRoom.g:4728:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:4681:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
-            // InternalRoom.g:4682:1: ( rule__RoomModel__DocuAssignment_2 )?
+            // InternalRoom.g:4728:1: ( ( rule__RoomModel__DocuAssignment_2 )? )
+            // InternalRoom.g:4729: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:4730: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:4730:2: rule__RoomModel__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RoomModel__DocuAssignment_2();
@@ -14629,14 +14785,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:4740: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:4744:1: ( rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4 )
+            // InternalRoom.g:4745:2: rule__RoomModel__Group__3__Impl rule__RoomModel__Group__4
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__3__Impl();
@@ -14667,17 +14823,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__3__Impl"
-    // InternalRoom.g:4705:1: rule__RoomModel__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:4752: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:4756:1: ( ( '{' ) )
+            // InternalRoom.g:4757:1: ( '{' )
             {
-            // InternalRoom.g:4710:1: ( '{' )
-            // InternalRoom.g:4711:1: '{'
+            // InternalRoom.g:4757:1: ( '{' )
+            // InternalRoom.g:4758:1: '{'
             {
              before(grammarAccess.getRoomModelAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -14704,14 +14860,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:4771: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:4775:1: ( rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5 )
+            // InternalRoom.g:4776:2: rule__RoomModel__Group__4__Impl rule__RoomModel__Group__5
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__4__Impl();
@@ -14742,33 +14898,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:4783: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:4787:1: ( ( ( rule__RoomModel__ImportsAssignment_4 )* ) )
+            // InternalRoom.g:4788:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
             {
-            // InternalRoom.g:4741:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
-            // InternalRoom.g:4742:1: ( rule__RoomModel__ImportsAssignment_4 )*
+            // InternalRoom.g:4788:1: ( ( rule__RoomModel__ImportsAssignment_4 )* )
+            // InternalRoom.g:4789:1: ( rule__RoomModel__ImportsAssignment_4 )*
             {
              before(grammarAccess.getRoomModelAccess().getImportsAssignment_4()); 
-            // InternalRoom.g:4743:1: ( rule__RoomModel__ImportsAssignment_4 )*
-            loop56:
+            // InternalRoom.g:4790: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:4790:2: rule__RoomModel__ImportsAssignment_4
             	    {
             	    pushFollow(FOLLOW_6);
             	    rule__RoomModel__ImportsAssignment_4();
@@ -14780,7 +14936,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop56;
+            	    break loop57;
                 }
             } while (true);
 
@@ -14807,14 +14963,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:4800: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:4804:1: ( rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6 )
+            // InternalRoom.g:4805:2: rule__RoomModel__Group__5__Impl rule__RoomModel__Group__6
             {
             pushFollow(FOLLOW_5);
             rule__RoomModel__Group__5__Impl();
@@ -14845,33 +15001,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:4812: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:4816:1: ( ( ( rule__RoomModel__Alternatives_5 )* ) )
+            // InternalRoom.g:4817:1: ( ( rule__RoomModel__Alternatives_5 )* )
             {
-            // InternalRoom.g:4770:1: ( ( rule__RoomModel__Alternatives_5 )* )
-            // InternalRoom.g:4771:1: ( rule__RoomModel__Alternatives_5 )*
+            // InternalRoom.g:4817:1: ( ( rule__RoomModel__Alternatives_5 )* )
+            // InternalRoom.g:4818:1: ( rule__RoomModel__Alternatives_5 )*
             {
              before(grammarAccess.getRoomModelAccess().getAlternatives_5()); 
-            // InternalRoom.g:4772:1: ( rule__RoomModel__Alternatives_5 )*
-            loop57:
+            // InternalRoom.g:4819: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:4819:2: rule__RoomModel__Alternatives_5
             	    {
             	    pushFollow(FOLLOW_7);
             	    rule__RoomModel__Alternatives_5();
@@ -14883,7 +15039,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop57;
+            	    break loop58;
                 }
             } while (true);
 
@@ -14910,14 +15066,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:4829: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:4833:1: ( rule__RoomModel__Group__6__Impl )
+            // InternalRoom.g:4834:2: rule__RoomModel__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RoomModel__Group__6__Impl();
@@ -14943,17 +15099,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__Group__6__Impl"
-    // InternalRoom.g:4793:1: rule__RoomModel__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:4840: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:4844:1: ( ( '}' ) )
+            // InternalRoom.g:4845:1: ( '}' )
             {
-            // InternalRoom.g:4798:1: ( '}' )
-            // InternalRoom.g:4799:1: '}'
+            // InternalRoom.g:4845:1: ( '}' )
+            // InternalRoom.g:4846:1: '}'
             {
              before(grammarAccess.getRoomModelAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -14980,14 +15136,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:4873: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:4877:1: ( rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1 )
+            // InternalRoom.g:4878:2: rule__VarDecl__Group__0__Impl rule__VarDecl__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__VarDecl__Group__0__Impl();
@@ -15018,21 +15174,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:4885: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:4889:1: ( ( ( rule__VarDecl__NameAssignment_0 ) ) )
+            // InternalRoom.g:4890:1: ( ( rule__VarDecl__NameAssignment_0 ) )
             {
-            // InternalRoom.g:4843:1: ( ( rule__VarDecl__NameAssignment_0 ) )
-            // InternalRoom.g:4844:1: ( rule__VarDecl__NameAssignment_0 )
+            // InternalRoom.g:4890:1: ( ( rule__VarDecl__NameAssignment_0 ) )
+            // InternalRoom.g:4891: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:4892:1: ( rule__VarDecl__NameAssignment_0 )
+            // InternalRoom.g:4892:2: rule__VarDecl__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__NameAssignment_0();
@@ -15065,14 +15221,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:4902: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:4906:1: ( rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2 )
+            // InternalRoom.g:4907:2: rule__VarDecl__Group__1__Impl rule__VarDecl__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__VarDecl__Group__1__Impl();
@@ -15103,17 +15259,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__Group__1__Impl"
-    // InternalRoom.g:4867:1: rule__VarDecl__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:4914: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:4918:1: ( ( ':' ) )
+            // InternalRoom.g:4919:1: ( ':' )
             {
-            // InternalRoom.g:4872:1: ( ':' )
-            // InternalRoom.g:4873:1: ':'
+            // InternalRoom.g:4919:1: ( ':' )
+            // InternalRoom.g:4920:1: ':'
             {
              before(grammarAccess.getVarDeclAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -15140,14 +15296,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:4933: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:4937:1: ( rule__VarDecl__Group__2__Impl )
+            // InternalRoom.g:4938:2: rule__VarDecl__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__Group__2__Impl();
@@ -15173,21 +15329,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:4944: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:4948:1: ( ( ( rule__VarDecl__RefTypeAssignment_2 ) ) )
+            // InternalRoom.g:4949:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
             {
-            // InternalRoom.g:4902:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
-            // InternalRoom.g:4903:1: ( rule__VarDecl__RefTypeAssignment_2 )
+            // InternalRoom.g:4949:1: ( ( rule__VarDecl__RefTypeAssignment_2 ) )
+            // InternalRoom.g:4950: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:4951:1: ( rule__VarDecl__RefTypeAssignment_2 )
+            // InternalRoom.g:4951:2: rule__VarDecl__RefTypeAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__VarDecl__RefTypeAssignment_2();
@@ -15220,14 +15376,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $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:4967: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:4971:1: ( rule__RefableType__Group__0__Impl rule__RefableType__Group__1 )
+            // InternalRoom.g:4972:2: rule__RefableType__Group__0__Impl rule__RefableType__Group__1
             {
             pushFollow(FOLLOW_9);
             rule__RefableType__Group__0__Impl();
@@ -15258,21 +15414,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:4979: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:4983:1: ( ( ( rule__RefableType__TypeAssignment_0 ) ) )
+            // InternalRoom.g:4984:1: ( ( rule__RefableType__TypeAssignment_0 ) )
             {
-            // InternalRoom.g:4937:1: ( ( rule__RefableType__TypeAssignment_0 ) )
-            // InternalRoom.g:4938:1: ( rule__RefableType__TypeAssignment_0 )
+            // InternalRoom.g:4984:1: ( ( rule__RefableType__TypeAssignment_0 ) )
+            // InternalRoom.g:4985: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:4986:1: ( rule__RefableType__TypeAssignment_0 )
+            // InternalRoom.g:4986:2: rule__RefableType__TypeAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefableType__TypeAssignment_0();
@@ -15305,14 +15461,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:4996: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:5000:1: ( rule__RefableType__Group__1__Impl )
+            // InternalRoom.g:5001:2: rule__RefableType__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefableType__Group__1__Impl();
@@ -15338,29 +15494,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:5007: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:5011:1: ( ( ( rule__RefableType__RefAssignment_1 )? ) )
+            // InternalRoom.g:5012:1: ( ( rule__RefableType__RefAssignment_1 )? )
             {
-            // InternalRoom.g:4965:1: ( ( rule__RefableType__RefAssignment_1 )? )
-            // InternalRoom.g:4966:1: ( rule__RefableType__RefAssignment_1 )?
+            // InternalRoom.g:5012:1: ( ( rule__RefableType__RefAssignment_1 )? )
+            // InternalRoom.g:5013: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:5014:1: ( rule__RefableType__RefAssignment_1 )?
+            int alt59=2;
+            int LA59_0 = input.LA(1);
 
-            if ( (LA58_0==91) ) {
-                alt58=1;
+            if ( (LA59_0==91) ) {
+                alt59=1;
             }
-            switch (alt58) {
+            switch (alt59) {
                 case 1 :
-                    // InternalRoom.g:4967:2: rule__RefableType__RefAssignment_1
+                    // InternalRoom.g:5014:2: rule__RefableType__RefAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefableType__RefAssignment_1();
@@ -15396,14 +15552,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:5028: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:5032:1: ( rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1 )
+            // InternalRoom.g:5033:2: rule__PrimitiveType__Group__0__Impl rule__PrimitiveType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__PrimitiveType__Group__0__Impl();
@@ -15434,17 +15590,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:5040: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:5044:1: ( ( 'PrimitiveType' ) )
+            // InternalRoom.g:5045:1: ( 'PrimitiveType' )
             {
-            // InternalRoom.g:4998:1: ( 'PrimitiveType' )
-            // InternalRoom.g:4999:1: 'PrimitiveType'
+            // InternalRoom.g:5045:1: ( 'PrimitiveType' )
+            // InternalRoom.g:5046:1: 'PrimitiveType'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getPrimitiveTypeKeyword_0()); 
             match(input,47,FOLLOW_2); 
@@ -15471,14 +15627,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:5059: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:5063:1: ( rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2 )
+            // InternalRoom.g:5064:2: rule__PrimitiveType__Group__1__Impl rule__PrimitiveType__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__PrimitiveType__Group__1__Impl();
@@ -15509,21 +15665,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:5071: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:5075:1: ( ( ( rule__PrimitiveType__NameAssignment_1 ) ) )
+            // InternalRoom.g:5076:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5029:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
-            // InternalRoom.g:5030:1: ( rule__PrimitiveType__NameAssignment_1 )
+            // InternalRoom.g:5076:1: ( ( rule__PrimitiveType__NameAssignment_1 ) )
+            // InternalRoom.g:5077: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:5078:1: ( rule__PrimitiveType__NameAssignment_1 )
+            // InternalRoom.g:5078:2: rule__PrimitiveType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__NameAssignment_1();
@@ -15556,14 +15712,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:5088: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:5092:1: ( rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3 )
+            // InternalRoom.g:5093:2: rule__PrimitiveType__Group__2__Impl rule__PrimitiveType__Group__3
             {
             pushFollow(FOLLOW_10);
             rule__PrimitiveType__Group__2__Impl();
@@ -15594,17 +15750,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__2__Impl"
-    // InternalRoom.g:5053:1: rule__PrimitiveType__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:5100: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:5104:1: ( ( ':' ) )
+            // InternalRoom.g:5105:1: ( ':' )
             {
-            // InternalRoom.g:5058:1: ( ':' )
-            // InternalRoom.g:5059:1: ':'
+            // InternalRoom.g:5105:1: ( ':' )
+            // InternalRoom.g:5106:1: ':'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -15631,14 +15787,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:5119: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:5123:1: ( rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4 )
+            // InternalRoom.g:5124:2: rule__PrimitiveType__Group__3__Impl rule__PrimitiveType__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__PrimitiveType__Group__3__Impl();
@@ -15669,21 +15825,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:5131: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:5135:1: ( ( ( rule__PrimitiveType__TypeAssignment_3 ) ) )
+            // InternalRoom.g:5136:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
             {
-            // InternalRoom.g:5089:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
-            // InternalRoom.g:5090:1: ( rule__PrimitiveType__TypeAssignment_3 )
+            // InternalRoom.g:5136:1: ( ( rule__PrimitiveType__TypeAssignment_3 ) )
+            // InternalRoom.g:5137: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:5138:1: ( rule__PrimitiveType__TypeAssignment_3 )
+            // InternalRoom.g:5138:2: rule__PrimitiveType__TypeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__TypeAssignment_3();
@@ -15716,14 +15872,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:5148: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:5152:1: ( rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5 )
+            // InternalRoom.g:5153:2: rule__PrimitiveType__Group__4__Impl rule__PrimitiveType__Group__5
             {
             pushFollow(FOLLOW_12);
             rule__PrimitiveType__Group__4__Impl();
@@ -15754,17 +15910,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__Group__4__Impl"
-    // InternalRoom.g:5113:1: rule__PrimitiveType__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:5160: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:5164:1: ( ( '->' ) )
+            // InternalRoom.g:5165:1: ( '->' )
             {
-            // InternalRoom.g:5118:1: ( '->' )
-            // InternalRoom.g:5119:1: '->'
+            // InternalRoom.g:5165:1: ( '->' )
+            // InternalRoom.g:5166:1: '->'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -15791,14 +15947,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:5179: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:5183:1: ( rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6 )
+            // InternalRoom.g:5184:2: rule__PrimitiveType__Group__5__Impl rule__PrimitiveType__Group__6
             {
             pushFollow(FOLLOW_13);
             rule__PrimitiveType__Group__5__Impl();
@@ -15829,21 +15985,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:5191: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:5195:1: ( ( ( rule__PrimitiveType__TargetNameAssignment_5 ) ) )
+            // InternalRoom.g:5196:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
             {
-            // InternalRoom.g:5149:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
-            // InternalRoom.g:5150:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
+            // InternalRoom.g:5196:1: ( ( rule__PrimitiveType__TargetNameAssignment_5 ) )
+            // InternalRoom.g:5197: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:5198:1: ( rule__PrimitiveType__TargetNameAssignment_5 )
+            // InternalRoom.g:5198:2: rule__PrimitiveType__TargetNameAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__TargetNameAssignment_5();
@@ -15876,14 +16032,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:5208: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:5212:1: ( rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7 )
+            // InternalRoom.g:5213:2: rule__PrimitiveType__Group__6__Impl rule__PrimitiveType__Group__7
             {
             pushFollow(FOLLOW_13);
             rule__PrimitiveType__Group__6__Impl();
@@ -15914,29 +16070,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:5220: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:5224:1: ( ( ( rule__PrimitiveType__Group_6__0 )? ) )
+            // InternalRoom.g:5225: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:5225:1: ( ( rule__PrimitiveType__Group_6__0 )? )
+            // InternalRoom.g:5226: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:5227:1: ( rule__PrimitiveType__Group_6__0 )?
+            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:5180:2: rule__PrimitiveType__Group_6__0
+                    // InternalRoom.g:5227:2: rule__PrimitiveType__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PrimitiveType__Group_6__0();
@@ -15972,14 +16128,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:5237: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:5241:1: ( rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8 )
+            // InternalRoom.g:5242:2: rule__PrimitiveType__Group__7__Impl rule__PrimitiveType__Group__8
             {
             pushFollow(FOLLOW_12);
             rule__PrimitiveType__Group__7__Impl();
@@ -16010,17 +16166,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:5249: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:5253:1: ( ( 'default' ) )
+            // InternalRoom.g:5254:1: ( 'default' )
             {
-            // InternalRoom.g:5207:1: ( 'default' )
-            // InternalRoom.g:5208:1: 'default'
+            // InternalRoom.g:5254:1: ( 'default' )
+            // InternalRoom.g:5255:1: 'default'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDefaultKeyword_7()); 
             match(input,49,FOLLOW_2); 
@@ -16047,14 +16203,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:5268: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:5272:1: ( rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9 )
+            // InternalRoom.g:5273:2: rule__PrimitiveType__Group__8__Impl rule__PrimitiveType__Group__9
             {
             pushFollow(FOLLOW_14);
             rule__PrimitiveType__Group__8__Impl();
@@ -16085,21 +16241,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:5280: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:5284:1: ( ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) ) )
+            // InternalRoom.g:5285:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
             {
-            // InternalRoom.g:5238:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
-            // InternalRoom.g:5239:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
+            // InternalRoom.g:5285:1: ( ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 ) )
+            // InternalRoom.g:5286: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:5287:1: ( rule__PrimitiveType__DefaultValueLiteralAssignment_8 )
+            // InternalRoom.g:5287:2: rule__PrimitiveType__DefaultValueLiteralAssignment_8
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__DefaultValueLiteralAssignment_8();
@@ -16132,14 +16288,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:5297: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:5301:1: ( rule__PrimitiveType__Group__9__Impl )
+            // InternalRoom.g:5302:2: rule__PrimitiveType__Group__9__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__Group__9__Impl();
@@ -16165,29 +16321,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:5308: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:5312:1: ( ( ( rule__PrimitiveType__DocuAssignment_9 )? ) )
+            // InternalRoom.g:5313:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
             {
-            // InternalRoom.g:5266:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
-            // InternalRoom.g:5267:1: ( rule__PrimitiveType__DocuAssignment_9 )?
+            // InternalRoom.g:5313:1: ( ( rule__PrimitiveType__DocuAssignment_9 )? )
+            // InternalRoom.g:5314: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:5315:1: ( rule__PrimitiveType__DocuAssignment_9 )?
+            int alt61=2;
+            int LA61_0 = input.LA(1);
 
-            if ( (LA60_0==62) ) {
-                alt60=1;
+            if ( (LA61_0==62) ) {
+                alt61=1;
             }
-            switch (alt60) {
+            switch (alt61) {
                 case 1 :
-                    // InternalRoom.g:5268:2: rule__PrimitiveType__DocuAssignment_9
+                    // InternalRoom.g:5315:2: rule__PrimitiveType__DocuAssignment_9
                     {
                     pushFollow(FOLLOW_2);
                     rule__PrimitiveType__DocuAssignment_9();
@@ -16223,14 +16379,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:5345: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:5349:1: ( rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1 )
+            // InternalRoom.g:5350:2: rule__PrimitiveType__Group_6__0__Impl rule__PrimitiveType__Group_6__1
             {
             pushFollow(FOLLOW_3);
             rule__PrimitiveType__Group_6__0__Impl();
@@ -16261,17 +16417,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:5357: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:5361:1: ( ( '(' ) )
+            // InternalRoom.g:5362:1: ( '(' )
             {
-            // InternalRoom.g:5315:1: ( '(' )
-            // InternalRoom.g:5316:1: '('
+            // InternalRoom.g:5362:1: ( '(' )
+            // InternalRoom.g:5363:1: '('
             {
              before(grammarAccess.getPrimitiveTypeAccess().getLeftParenthesisKeyword_6_0()); 
             match(input,50,FOLLOW_2); 
@@ -16298,14 +16454,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:5376: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:5380:1: ( rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2 )
+            // InternalRoom.g:5381:2: rule__PrimitiveType__Group_6__1__Impl rule__PrimitiveType__Group_6__2
             {
             pushFollow(FOLLOW_15);
             rule__PrimitiveType__Group_6__1__Impl();
@@ -16336,21 +16492,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:5388: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:5392:1: ( ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) ) )
+            // InternalRoom.g:5393: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:5393:1: ( ( rule__PrimitiveType__CastNameAssignment_6_1 ) )
+            // InternalRoom.g:5394: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:5395:1: ( rule__PrimitiveType__CastNameAssignment_6_1 )
+            // InternalRoom.g:5395:2: rule__PrimitiveType__CastNameAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__CastNameAssignment_6_1();
@@ -16383,14 +16539,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:5405: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:5409:1: ( rule__PrimitiveType__Group_6__2__Impl )
+            // InternalRoom.g:5410:2: rule__PrimitiveType__Group_6__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PrimitiveType__Group_6__2__Impl();
@@ -16416,17 +16572,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:5416: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:5420:1: ( ( ')' ) )
+            // InternalRoom.g:5421:1: ( ')' )
             {
-            // InternalRoom.g:5374:1: ( ')' )
-            // InternalRoom.g:5375:1: ')'
+            // InternalRoom.g:5421:1: ( ')' )
+            // InternalRoom.g:5422:1: ')'
             {
              before(grammarAccess.getPrimitiveTypeAccess().getRightParenthesisKeyword_6_2()); 
             match(input,51,FOLLOW_2); 
@@ -16453,14 +16609,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:5441: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:5445:1: ( rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1 )
+            // InternalRoom.g:5446:2: rule__EnumerationType__Group__0__Impl rule__EnumerationType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__EnumerationType__Group__0__Impl();
@@ -16491,17 +16647,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:5453: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:5457:1: ( ( 'Enumeration' ) )
+            // InternalRoom.g:5458:1: ( 'Enumeration' )
             {
-            // InternalRoom.g:5411:1: ( 'Enumeration' )
-            // InternalRoom.g:5412:1: 'Enumeration'
+            // InternalRoom.g:5458:1: ( 'Enumeration' )
+            // InternalRoom.g:5459:1: 'Enumeration'
             {
              before(grammarAccess.getEnumerationTypeAccess().getEnumerationKeyword_0()); 
             match(input,52,FOLLOW_2); 
@@ -16528,14 +16684,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:5472: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:5476:1: ( rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2 )
+            // InternalRoom.g:5477:2: rule__EnumerationType__Group__1__Impl rule__EnumerationType__Group__2
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__1__Impl();
@@ -16566,21 +16722,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:5484: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:5488:1: ( ( ( rule__EnumerationType__NameAssignment_1 ) ) )
+            // InternalRoom.g:5489:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5442:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
-            // InternalRoom.g:5443:1: ( rule__EnumerationType__NameAssignment_1 )
+            // InternalRoom.g:5489:1: ( ( rule__EnumerationType__NameAssignment_1 ) )
+            // InternalRoom.g:5490: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:5491:1: ( rule__EnumerationType__NameAssignment_1 )
+            // InternalRoom.g:5491:2: rule__EnumerationType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__NameAssignment_1();
@@ -16613,14 +16769,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:5501: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:5505:1: ( rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3 )
+            // InternalRoom.g:5506:2: rule__EnumerationType__Group__2__Impl rule__EnumerationType__Group__3
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__2__Impl();
@@ -16651,29 +16807,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:5513: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:5517:1: ( ( ( rule__EnumerationType__DocuAssignment_2 )? ) )
+            // InternalRoom.g:5518:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:5471:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
-            // InternalRoom.g:5472:1: ( rule__EnumerationType__DocuAssignment_2 )?
+            // InternalRoom.g:5518:1: ( ( rule__EnumerationType__DocuAssignment_2 )? )
+            // InternalRoom.g:5519: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:5520:1: ( rule__EnumerationType__DocuAssignment_2 )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
 
-            if ( (LA61_0==62) ) {
-                alt61=1;
+            if ( (LA62_0==62) ) {
+                alt62=1;
             }
-            switch (alt61) {
+            switch (alt62) {
                 case 1 :
-                    // InternalRoom.g:5473:2: rule__EnumerationType__DocuAssignment_2
+                    // InternalRoom.g:5520:2: rule__EnumerationType__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__DocuAssignment_2();
@@ -16709,14 +16865,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:5530: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:5534:1: ( rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4 )
+            // InternalRoom.g:5535:2: rule__EnumerationType__Group__3__Impl rule__EnumerationType__Group__4
             {
             pushFollow(FOLLOW_16);
             rule__EnumerationType__Group__3__Impl();
@@ -16747,29 +16903,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:5542: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:5546:1: ( ( ( rule__EnumerationType__Group_3__0 )? ) )
+            // InternalRoom.g:5547: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:5547:1: ( ( rule__EnumerationType__Group_3__0 )? )
+            // InternalRoom.g:5548: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:5549:1: ( rule__EnumerationType__Group_3__0 )?
+            int alt63=2;
+            int LA63_0 = input.LA(1);
 
-            if ( (LA62_0==53) ) {
-                alt62=1;
+            if ( (LA63_0==53) ) {
+                alt63=1;
             }
-            switch (alt62) {
+            switch (alt63) {
                 case 1 :
-                    // InternalRoom.g:5502:2: rule__EnumerationType__Group_3__0
+                    // InternalRoom.g:5549:2: rule__EnumerationType__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__Group_3__0();
@@ -16805,14 +16961,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:5559: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:5563:1: ( rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5 )
+            // InternalRoom.g:5564:2: rule__EnumerationType__Group__4__Impl rule__EnumerationType__Group__5
             {
             pushFollow(FOLLOW_17);
             rule__EnumerationType__Group__4__Impl();
@@ -16843,17 +16999,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__4__Impl"
-    // InternalRoom.g:5524:1: rule__EnumerationType__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:5571: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:5575:1: ( ( '{' ) )
+            // InternalRoom.g:5576:1: ( '{' )
             {
-            // InternalRoom.g:5529:1: ( '{' )
-            // InternalRoom.g:5530:1: '{'
+            // InternalRoom.g:5576:1: ( '{' )
+            // InternalRoom.g:5577:1: '{'
             {
              before(grammarAccess.getEnumerationTypeAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -16880,14 +17036,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:5590: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:5594:1: ( rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6 )
+            // InternalRoom.g:5595:2: rule__EnumerationType__Group__5__Impl rule__EnumerationType__Group__6
             {
             pushFollow(FOLLOW_17);
             rule__EnumerationType__Group__5__Impl();
@@ -16918,29 +17074,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:5602: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:5606:1: ( ( ( rule__EnumerationType__Group_5__0 )? ) )
+            // InternalRoom.g:5607: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:5607:1: ( ( rule__EnumerationType__Group_5__0 )? )
+            // InternalRoom.g:5608: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:5609:1: ( rule__EnumerationType__Group_5__0 )?
+            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 :
-                    // InternalRoom.g:5562:2: rule__EnumerationType__Group_5__0
+                    // InternalRoom.g:5609:2: rule__EnumerationType__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumerationType__Group_5__0();
@@ -16976,14 +17132,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:5619: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:5623:1: ( rule__EnumerationType__Group__6__Impl )
+            // InternalRoom.g:5624:2: rule__EnumerationType__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group__6__Impl();
@@ -17009,17 +17165,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__Group__6__Impl"
-    // InternalRoom.g:5583:1: rule__EnumerationType__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:5630: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:5634:1: ( ( '}' ) )
+            // InternalRoom.g:5635:1: ( '}' )
             {
-            // InternalRoom.g:5588:1: ( '}' )
-            // InternalRoom.g:5589:1: '}'
+            // InternalRoom.g:5635:1: ( '}' )
+            // InternalRoom.g:5636:1: '}'
             {
              before(grammarAccess.getEnumerationTypeAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -17046,14 +17202,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:5663: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:5667:1: ( rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1 )
+            // InternalRoom.g:5668:2: rule__EnumerationType__Group_3__0__Impl rule__EnumerationType__Group_3__1
             {
             pushFollow(FOLLOW_3);
             rule__EnumerationType__Group_3__0__Impl();
@@ -17084,17 +17240,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:5675: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:5679:1: ( ( 'of' ) )
+            // InternalRoom.g:5680:1: ( 'of' )
             {
-            // InternalRoom.g:5633:1: ( 'of' )
-            // InternalRoom.g:5634:1: 'of'
+            // InternalRoom.g:5680:1: ( 'of' )
+            // InternalRoom.g:5681:1: 'of'
             {
              before(grammarAccess.getEnumerationTypeAccess().getOfKeyword_3_0()); 
             match(input,53,FOLLOW_2); 
@@ -17121,14 +17277,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:5694: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:5698:1: ( rule__EnumerationType__Group_3__1__Impl )
+            // InternalRoom.g:5699:2: rule__EnumerationType__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_3__1__Impl();
@@ -17154,21 +17310,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:5705: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:5709:1: ( ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) ) )
+            // InternalRoom.g:5710: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:5710:1: ( ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 ) )
+            // InternalRoom.g:5711: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:5712:1: ( rule__EnumerationType__PrimitiveTypeAssignment_3_1 )
+            // InternalRoom.g:5712:2: rule__EnumerationType__PrimitiveTypeAssignment_3_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__PrimitiveTypeAssignment_3_1();
@@ -17201,14 +17357,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:5726: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:5730:1: ( rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1 )
+            // InternalRoom.g:5731:2: rule__EnumerationType__Group_5__0__Impl rule__EnumerationType__Group_5__1
             {
             pushFollow(FOLLOW_18);
             rule__EnumerationType__Group_5__0__Impl();
@@ -17239,21 +17395,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:5738: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:5742:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) ) )
+            // InternalRoom.g:5743: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:5743:1: ( ( rule__EnumerationType__LiteralsAssignment_5_0 ) )
+            // InternalRoom.g:5744: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:5745:1: ( rule__EnumerationType__LiteralsAssignment_5_0 )
+            // InternalRoom.g:5745:2: rule__EnumerationType__LiteralsAssignment_5_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__LiteralsAssignment_5_0();
@@ -17286,14 +17442,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:5755: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:5759:1: ( rule__EnumerationType__Group_5__1__Impl )
+            // InternalRoom.g:5760:2: rule__EnumerationType__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_5__1__Impl();
@@ -17319,33 +17475,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:5766: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:5770:1: ( ( ( rule__EnumerationType__Group_5_1__0 )* ) )
+            // InternalRoom.g:5771: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:5771:1: ( ( rule__EnumerationType__Group_5_1__0 )* )
+            // InternalRoom.g:5772: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:5773:1: ( rule__EnumerationType__Group_5_1__0 )*
+            loop65:
             do {
-                int alt64=2;
-                int LA64_0 = input.LA(1);
+                int alt65=2;
+                int LA65_0 = input.LA(1);
 
-                if ( (LA64_0==54) ) {
-                    alt64=1;
+                if ( (LA65_0==54) ) {
+                    alt65=1;
                 }
 
 
-                switch (alt64) {
+                switch (alt65) {
             	case 1 :
-            	    // InternalRoom.g:5726:2: rule__EnumerationType__Group_5_1__0
+            	    // InternalRoom.g:5773:2: rule__EnumerationType__Group_5_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__EnumerationType__Group_5_1__0();
@@ -17357,7 +17513,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop64;
+            	    break loop65;
                 }
             } while (true);
 
@@ -17384,14 +17540,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:5787: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:5791:1: ( rule__EnumerationType__Group_5_1__0__Impl rule__EnumerationType__Group_5_1__1 )
+            // InternalRoom.g:5792: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 +17578,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:5799: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:5803:1: ( ( ',' ) )
+            // InternalRoom.g:5804:1: ( ',' )
             {
-            // InternalRoom.g:5757:1: ( ',' )
-            // InternalRoom.g:5758:1: ','
+            // InternalRoom.g:5804:1: ( ',' )
+            // InternalRoom.g:5805:1: ','
             {
              before(grammarAccess.getEnumerationTypeAccess().getCommaKeyword_5_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -17459,14 +17615,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:5818: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:5822:1: ( rule__EnumerationType__Group_5_1__1__Impl )
+            // InternalRoom.g:5823:2: rule__EnumerationType__Group_5_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__Group_5_1__1__Impl();
@@ -17492,21 +17648,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:5829: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:5833:1: ( ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) ) )
+            // InternalRoom.g:5834: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:5834:1: ( ( rule__EnumerationType__LiteralsAssignment_5_1_1 ) )
+            // InternalRoom.g:5835: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:5836:1: ( rule__EnumerationType__LiteralsAssignment_5_1_1 )
+            // InternalRoom.g:5836:2: rule__EnumerationType__LiteralsAssignment_5_1_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumerationType__LiteralsAssignment_5_1_1();
@@ -17539,14 +17695,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:5850: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:5854:1: ( rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1 )
+            // InternalRoom.g:5855:2: rule__EnumLiteral__Group__0__Impl rule__EnumLiteral__Group__1
             {
             pushFollow(FOLLOW_20);
             rule__EnumLiteral__Group__0__Impl();
@@ -17577,21 +17733,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:5862: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:5866:1: ( ( ( rule__EnumLiteral__NameAssignment_0 ) ) )
+            // InternalRoom.g:5867:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
             {
-            // InternalRoom.g:5820:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
-            // InternalRoom.g:5821:1: ( rule__EnumLiteral__NameAssignment_0 )
+            // InternalRoom.g:5867:1: ( ( rule__EnumLiteral__NameAssignment_0 ) )
+            // InternalRoom.g:5868: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:5869:1: ( rule__EnumLiteral__NameAssignment_0 )
+            // InternalRoom.g:5869:2: rule__EnumLiteral__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__NameAssignment_0();
@@ -17624,14 +17780,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:5879: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:5883:1: ( rule__EnumLiteral__Group__1__Impl )
+            // InternalRoom.g:5884:2: rule__EnumLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__Group__1__Impl();
@@ -17657,29 +17813,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:5890: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:5894:1: ( ( ( rule__EnumLiteral__Group_1__0 )? ) )
+            // InternalRoom.g:5895: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:5895:1: ( ( rule__EnumLiteral__Group_1__0 )? )
+            // InternalRoom.g:5896: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:5897:1: ( rule__EnumLiteral__Group_1__0 )?
+            int alt66=2;
+            int LA66_0 = input.LA(1);
 
-            if ( (LA65_0==55) ) {
-                alt65=1;
+            if ( (LA66_0==55) ) {
+                alt66=1;
             }
-            switch (alt65) {
+            switch (alt66) {
                 case 1 :
-                    // InternalRoom.g:5850:2: rule__EnumLiteral__Group_1__0
+                    // InternalRoom.g:5897:2: rule__EnumLiteral__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__EnumLiteral__Group_1__0();
@@ -17715,14 +17871,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:5911: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:5915:1: ( rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1 )
+            // InternalRoom.g:5916:2: rule__EnumLiteral__Group_1__0__Impl rule__EnumLiteral__Group_1__1
             {
             pushFollow(FOLLOW_21);
             rule__EnumLiteral__Group_1__0__Impl();
@@ -17753,17 +17909,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:5923: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:5927:1: ( ( '=' ) )
+            // InternalRoom.g:5928:1: ( '=' )
             {
-            // InternalRoom.g:5881:1: ( '=' )
-            // InternalRoom.g:5882:1: '='
+            // InternalRoom.g:5928:1: ( '=' )
+            // InternalRoom.g:5929:1: '='
             {
              before(grammarAccess.getEnumLiteralAccess().getEqualsSignKeyword_1_0()); 
             match(input,55,FOLLOW_2); 
@@ -17790,14 +17946,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:5942: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:5946:1: ( rule__EnumLiteral__Group_1__1__Impl )
+            // InternalRoom.g:5947:2: rule__EnumLiteral__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__Group_1__1__Impl();
@@ -17823,21 +17979,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:5953: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:5957:1: ( ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) ) )
+            // InternalRoom.g:5958: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:5958:1: ( ( rule__EnumLiteral__LiteralAssignment_1_1 ) )
+            // InternalRoom.g:5959: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:5960:1: ( rule__EnumLiteral__LiteralAssignment_1_1 )
+            // InternalRoom.g:5960:2: rule__EnumLiteral__LiteralAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumLiteral__LiteralAssignment_1_1();
@@ -17870,14 +18026,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:5974: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:5978:1: ( rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1 )
+            // InternalRoom.g:5979:2: rule__ExternalType__Group__0__Impl rule__ExternalType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ExternalType__Group__0__Impl();
@@ -17908,17 +18064,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:5986: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:5990:1: ( ( 'ExternalType' ) )
+            // InternalRoom.g:5991:1: ( 'ExternalType' )
             {
-            // InternalRoom.g:5944:1: ( 'ExternalType' )
-            // InternalRoom.g:5945:1: 'ExternalType'
+            // InternalRoom.g:5991:1: ( 'ExternalType' )
+            // InternalRoom.g:5992:1: 'ExternalType'
             {
              before(grammarAccess.getExternalTypeAccess().getExternalTypeKeyword_0()); 
             match(input,56,FOLLOW_2); 
@@ -17945,14 +18101,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:6005: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:6009:1: ( rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2 )
+            // InternalRoom.g:6010:2: rule__ExternalType__Group__1__Impl rule__ExternalType__Group__2
             {
             pushFollow(FOLLOW_11);
             rule__ExternalType__Group__1__Impl();
@@ -17983,21 +18139,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:6017: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:6021:1: ( ( ( rule__ExternalType__NameAssignment_1 ) ) )
+            // InternalRoom.g:6022:1: ( ( rule__ExternalType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:5975:1: ( ( rule__ExternalType__NameAssignment_1 ) )
-            // InternalRoom.g:5976:1: ( rule__ExternalType__NameAssignment_1 )
+            // InternalRoom.g:6022:1: ( ( rule__ExternalType__NameAssignment_1 ) )
+            // InternalRoom.g:6023: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:6024:1: ( rule__ExternalType__NameAssignment_1 )
+            // InternalRoom.g:6024:2: rule__ExternalType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__NameAssignment_1();
@@ -18030,14 +18186,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:6034: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:6038:1: ( rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3 )
+            // InternalRoom.g:6039:2: rule__ExternalType__Group__2__Impl rule__ExternalType__Group__3
             {
             pushFollow(FOLLOW_12);
             rule__ExternalType__Group__2__Impl();
@@ -18068,17 +18224,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__Group__2__Impl"
-    // InternalRoom.g:5999:1: rule__ExternalType__Group__2__Impl : ( '->' ) ;
+    // InternalRoom.g:6046: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:6050:1: ( ( '->' ) )
+            // InternalRoom.g:6051:1: ( '->' )
             {
-            // InternalRoom.g:6004:1: ( '->' )
-            // InternalRoom.g:6005:1: '->'
+            // InternalRoom.g:6051:1: ( '->' )
+            // InternalRoom.g:6052:1: '->'
             {
              before(grammarAccess.getExternalTypeAccess().getHyphenMinusGreaterThanSignKeyword_2()); 
             match(input,48,FOLLOW_2); 
@@ -18105,14 +18261,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:6065: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:6069:1: ( rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4 )
+            // InternalRoom.g:6070:2: rule__ExternalType__Group__3__Impl rule__ExternalType__Group__4
             {
             pushFollow(FOLLOW_22);
             rule__ExternalType__Group__3__Impl();
@@ -18143,21 +18299,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:6077: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:6081:1: ( ( ( rule__ExternalType__TargetNameAssignment_3 ) ) )
+            // InternalRoom.g:6082:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
             {
-            // InternalRoom.g:6035:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
-            // InternalRoom.g:6036:1: ( rule__ExternalType__TargetNameAssignment_3 )
+            // InternalRoom.g:6082:1: ( ( rule__ExternalType__TargetNameAssignment_3 ) )
+            // InternalRoom.g:6083: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:6084:1: ( rule__ExternalType__TargetNameAssignment_3 )
+            // InternalRoom.g:6084:2: rule__ExternalType__TargetNameAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__TargetNameAssignment_3();
@@ -18190,14 +18346,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:6094: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:6098:1: ( rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5 )
+            // InternalRoom.g:6099:2: rule__ExternalType__Group__4__Impl rule__ExternalType__Group__5
             {
             pushFollow(FOLLOW_22);
             rule__ExternalType__Group__4__Impl();
@@ -18228,29 +18384,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:6106: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:6110:1: ( ( ( rule__ExternalType__Group_4__0 )? ) )
+            // InternalRoom.g:6111: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:6111:1: ( ( rule__ExternalType__Group_4__0 )? )
+            // InternalRoom.g:6112: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:6113:1: ( rule__ExternalType__Group_4__0 )?
+            int alt67=2;
+            int LA67_0 = input.LA(1);
 
-            if ( (LA66_0==49) ) {
-                alt66=1;
+            if ( (LA67_0==49) ) {
+                alt67=1;
             }
-            switch (alt66) {
+            switch (alt67) {
                 case 1 :
-                    // InternalRoom.g:6066:2: rule__ExternalType__Group_4__0
+                    // InternalRoom.g:6113:2: rule__ExternalType__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ExternalType__Group_4__0();
@@ -18286,14 +18442,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:6123: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:6127:1: ( rule__ExternalType__Group__5__Impl )
+            // InternalRoom.g:6128:2: rule__ExternalType__Group__5__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__Group__5__Impl();
@@ -18319,29 +18475,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:6134: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:6138:1: ( ( ( rule__ExternalType__DocuAssignment_5 )? ) )
+            // InternalRoom.g:6139:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
             {
-            // InternalRoom.g:6092:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
-            // InternalRoom.g:6093:1: ( rule__ExternalType__DocuAssignment_5 )?
+            // InternalRoom.g:6139:1: ( ( rule__ExternalType__DocuAssignment_5 )? )
+            // InternalRoom.g:6140: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:6141:1: ( rule__ExternalType__DocuAssignment_5 )?
+            int alt68=2;
+            int LA68_0 = input.LA(1);
 
-            if ( (LA67_0==62) ) {
-                alt67=1;
+            if ( (LA68_0==62) ) {
+                alt68=1;
             }
-            switch (alt67) {
+            switch (alt68) {
                 case 1 :
-                    // InternalRoom.g:6094:2: rule__ExternalType__DocuAssignment_5
+                    // InternalRoom.g:6141:2: rule__ExternalType__DocuAssignment_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ExternalType__DocuAssignment_5();
@@ -18377,14 +18533,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:6163: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:6167:1: ( rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1 )
+            // InternalRoom.g:6168:2: rule__ExternalType__Group_4__0__Impl rule__ExternalType__Group_4__1
             {
             pushFollow(FOLLOW_12);
             rule__ExternalType__Group_4__0__Impl();
@@ -18415,17 +18571,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:6175: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:6179:1: ( ( 'default' ) )
+            // InternalRoom.g:6180:1: ( 'default' )
             {
-            // InternalRoom.g:6133:1: ( 'default' )
-            // InternalRoom.g:6134:1: 'default'
+            // InternalRoom.g:6180:1: ( 'default' )
+            // InternalRoom.g:6181:1: 'default'
             {
              before(grammarAccess.getExternalTypeAccess().getDefaultKeyword_4_0()); 
             match(input,49,FOLLOW_2); 
@@ -18452,14 +18608,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:6194: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:6198:1: ( rule__ExternalType__Group_4__1__Impl )
+            // InternalRoom.g:6199:2: rule__ExternalType__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__Group_4__1__Impl();
@@ -18485,21 +18641,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:6205: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:6209:1: ( ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) ) )
+            // InternalRoom.g:6210: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:6210:1: ( ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 ) )
+            // InternalRoom.g:6211: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:6212:1: ( rule__ExternalType__DefaultValueLiteralAssignment_4_1 )
+            // InternalRoom.g:6212:2: rule__ExternalType__DefaultValueLiteralAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ExternalType__DefaultValueLiteralAssignment_4_1();
@@ -18532,14 +18688,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:6226: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:6230:1: ( rule__DataClass__Group__0__Impl rule__DataClass__Group__1 )
+            // InternalRoom.g:6231:2: rule__DataClass__Group__0__Impl rule__DataClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__DataClass__Group__0__Impl();
@@ -18570,17 +18726,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:6238: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:6242:1: ( ( 'DataClass' ) )
+            // InternalRoom.g:6243:1: ( 'DataClass' )
             {
-            // InternalRoom.g:6196:1: ( 'DataClass' )
-            // InternalRoom.g:6197:1: 'DataClass'
+            // InternalRoom.g:6243:1: ( 'DataClass' )
+            // InternalRoom.g:6244:1: 'DataClass'
             {
              before(grammarAccess.getDataClassAccess().getDataClassKeyword_0()); 
             match(input,17,FOLLOW_2); 
@@ -18607,14 +18763,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:6257: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:6261:1: ( rule__DataClass__Group__1__Impl rule__DataClass__Group__2 )
+            // InternalRoom.g:6262:2: rule__DataClass__Group__1__Impl rule__DataClass__Group__2
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__1__Impl();
@@ -18645,21 +18801,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:6269: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:6273:1: ( ( ( rule__DataClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:6274:1: ( ( rule__DataClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:6227:1: ( ( rule__DataClass__NameAssignment_1 ) )
-            // InternalRoom.g:6228:1: ( rule__DataClass__NameAssignment_1 )
+            // InternalRoom.g:6274:1: ( ( rule__DataClass__NameAssignment_1 ) )
+            // InternalRoom.g:6275: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:6276:1: ( rule__DataClass__NameAssignment_1 )
+            // InternalRoom.g:6276:2: rule__DataClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__NameAssignment_1();
@@ -18692,14 +18848,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:6286: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:6290:1: ( rule__DataClass__Group__2__Impl rule__DataClass__Group__3 )
+            // InternalRoom.g:6291:2: rule__DataClass__Group__2__Impl rule__DataClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__2__Impl();
@@ -18730,29 +18886,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:6298: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:6302:1: ( ( ( rule__DataClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:6303:1: ( ( rule__DataClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:6256:1: ( ( rule__DataClass__DocuAssignment_2 )? )
-            // InternalRoom.g:6257:1: ( rule__DataClass__DocuAssignment_2 )?
+            // InternalRoom.g:6303:1: ( ( rule__DataClass__DocuAssignment_2 )? )
+            // InternalRoom.g:6304: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:6305:1: ( rule__DataClass__DocuAssignment_2 )?
+            int alt69=2;
+            int LA69_0 = input.LA(1);
 
-            if ( (LA68_0==62) ) {
-                alt68=1;
+            if ( (LA69_0==62) ) {
+                alt69=1;
             }
-            switch (alt68) {
+            switch (alt69) {
                 case 1 :
-                    // InternalRoom.g:6258:2: rule__DataClass__DocuAssignment_2
+                    // InternalRoom.g:6305:2: rule__DataClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__DocuAssignment_2();
@@ -18788,14 +18944,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:6315: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:6319:1: ( rule__DataClass__Group__3__Impl rule__DataClass__Group__4 )
+            // InternalRoom.g:6320:2: rule__DataClass__Group__3__Impl rule__DataClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__DataClass__Group__3__Impl();
@@ -18826,29 +18982,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:6327: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:6331:1: ( ( ( rule__DataClass__Group_3__0 )? ) )
+            // InternalRoom.g:6332: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:6332:1: ( ( rule__DataClass__Group_3__0 )? )
+            // InternalRoom.g:6333: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:6334:1: ( rule__DataClass__Group_3__0 )?
+            int alt70=2;
+            int LA70_0 = input.LA(1);
 
-            if ( (LA69_0==57) ) {
-                alt69=1;
+            if ( (LA70_0==57) ) {
+                alt70=1;
             }
-            switch (alt69) {
+            switch (alt70) {
                 case 1 :
-                    // InternalRoom.g:6287:2: rule__DataClass__Group_3__0
+                    // InternalRoom.g:6334:2: rule__DataClass__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_3__0();
@@ -18884,14 +19040,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:6344: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:6348:1: ( rule__DataClass__Group__4__Impl rule__DataClass__Group__5 )
+            // InternalRoom.g:6349:2: rule__DataClass__Group__4__Impl rule__DataClass__Group__5
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__4__Impl();
@@ -18922,17 +19078,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__4__Impl"
-    // InternalRoom.g:6309:1: rule__DataClass__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:6356: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:6360:1: ( ( '{' ) )
+            // InternalRoom.g:6361:1: ( '{' )
             {
-            // InternalRoom.g:6314:1: ( '{' )
-            // InternalRoom.g:6315:1: '{'
+            // InternalRoom.g:6361:1: ( '{' )
+            // InternalRoom.g:6362:1: '{'
             {
              before(grammarAccess.getDataClassAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -18959,14 +19115,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:6375: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:6379:1: ( rule__DataClass__Group__5__Impl rule__DataClass__Group__6 )
+            // InternalRoom.g:6380:2: rule__DataClass__Group__5__Impl rule__DataClass__Group__6
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__5__Impl();
@@ -18997,33 +19153,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:6387: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:6391:1: ( ( ( rule__DataClass__AnnotationsAssignment_5 )* ) )
+            // InternalRoom.g:6392:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
             {
-            // InternalRoom.g:6345:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
-            // InternalRoom.g:6346:1: ( rule__DataClass__AnnotationsAssignment_5 )*
+            // InternalRoom.g:6392:1: ( ( rule__DataClass__AnnotationsAssignment_5 )* )
+            // InternalRoom.g:6393:1: ( rule__DataClass__AnnotationsAssignment_5 )*
             {
              before(grammarAccess.getDataClassAccess().getAnnotationsAssignment_5()); 
-            // InternalRoom.g:6347:1: ( rule__DataClass__AnnotationsAssignment_5 )*
-            loop70:
+            // InternalRoom.g:6394:1: ( rule__DataClass__AnnotationsAssignment_5 )*
+            loop71:
             do {
-                int alt70=2;
-                int LA70_0 = input.LA(1);
+                int alt71=2;
+                int LA71_0 = input.LA(1);
 
-                if ( (LA70_0==121) ) {
-                    alt70=1;
+                if ( (LA71_0==121) ) {
+                    alt71=1;
                 }
 
 
-                switch (alt70) {
+                switch (alt71) {
             	case 1 :
-            	    // InternalRoom.g:6347:2: rule__DataClass__AnnotationsAssignment_5
+            	    // InternalRoom.g:6394:2: rule__DataClass__AnnotationsAssignment_5
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__DataClass__AnnotationsAssignment_5();
@@ -19035,7 +19191,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop70;
+            	    break loop71;
                 }
             } while (true);
 
@@ -19062,14 +19218,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:6404: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:6408:1: ( rule__DataClass__Group__6__Impl rule__DataClass__Group__7 )
+            // InternalRoom.g:6409:2: rule__DataClass__Group__6__Impl rule__DataClass__Group__7
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__6__Impl();
@@ -19100,29 +19256,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:6416: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:6420:1: ( ( ( rule__DataClass__Group_6__0 )? ) )
+            // InternalRoom.g:6421: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:6421:1: ( ( rule__DataClass__Group_6__0 )? )
+            // InternalRoom.g:6422: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:6423:1: ( rule__DataClass__Group_6__0 )?
+            int alt72=2;
+            int LA72_0 = input.LA(1);
 
-            if ( (LA71_0==58) ) {
-                alt71=1;
+            if ( (LA72_0==58) ) {
+                alt72=1;
             }
-            switch (alt71) {
+            switch (alt72) {
                 case 1 :
-                    // InternalRoom.g:6376:2: rule__DataClass__Group_6__0
+                    // InternalRoom.g:6423:2: rule__DataClass__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_6__0();
@@ -19158,14 +19314,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:6433: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:6437:1: ( rule__DataClass__Group__7__Impl rule__DataClass__Group__8 )
+            // InternalRoom.g:6438:2: rule__DataClass__Group__7__Impl rule__DataClass__Group__8
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__7__Impl();
@@ -19196,29 +19352,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:6445: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:6449:1: ( ( ( rule__DataClass__Group_7__0 )? ) )
+            // InternalRoom.g:6450: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:6450:1: ( ( rule__DataClass__Group_7__0 )? )
+            // InternalRoom.g:6451: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:6452:1: ( rule__DataClass__Group_7__0 )?
+            int alt73=2;
+            int LA73_0 = input.LA(1);
 
-            if ( (LA72_0==59) ) {
-                alt72=1;
+            if ( (LA73_0==59) ) {
+                alt73=1;
             }
-            switch (alt72) {
+            switch (alt73) {
                 case 1 :
-                    // InternalRoom.g:6405:2: rule__DataClass__Group_7__0
+                    // InternalRoom.g:6452:2: rule__DataClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_7__0();
@@ -19254,14 +19410,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:6462: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:6466:1: ( rule__DataClass__Group__8__Impl rule__DataClass__Group__9 )
+            // InternalRoom.g:6467:2: rule__DataClass__Group__8__Impl rule__DataClass__Group__9
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__8__Impl();
@@ -19292,29 +19448,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:6474: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:6478:1: ( ( ( rule__DataClass__Group_8__0 )? ) )
+            // InternalRoom.g:6479: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:6479:1: ( ( rule__DataClass__Group_8__0 )? )
+            // InternalRoom.g:6480: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:6481:1: ( rule__DataClass__Group_8__0 )?
+            int alt74=2;
+            int LA74_0 = input.LA(1);
 
-            if ( (LA73_0==60) ) {
-                alt73=1;
+            if ( (LA74_0==60) ) {
+                alt74=1;
             }
-            switch (alt73) {
+            switch (alt74) {
                 case 1 :
-                    // InternalRoom.g:6434:2: rule__DataClass__Group_8__0
+                    // InternalRoom.g:6481:2: rule__DataClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DataClass__Group_8__0();
@@ -19350,14 +19506,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:6491: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:6495:1: ( rule__DataClass__Group__9__Impl rule__DataClass__Group__10 )
+            // InternalRoom.g:6496:2: rule__DataClass__Group__9__Impl rule__DataClass__Group__10
             {
             pushFollow(FOLLOW_24);
             rule__DataClass__Group__9__Impl();
@@ -19388,33 +19544,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:6503: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:6507:1: ( ( ( rule__DataClass__Alternatives_9 )* ) )
+            // InternalRoom.g:6508:1: ( ( rule__DataClass__Alternatives_9 )* )
             {
-            // InternalRoom.g:6461:1: ( ( rule__DataClass__Alternatives_9 )* )
-            // InternalRoom.g:6462:1: ( rule__DataClass__Alternatives_9 )*
+            // InternalRoom.g:6508:1: ( ( rule__DataClass__Alternatives_9 )* )
+            // InternalRoom.g:6509:1: ( rule__DataClass__Alternatives_9 )*
             {
              before(grammarAccess.getDataClassAccess().getAlternatives_9()); 
-            // InternalRoom.g:6463:1: ( rule__DataClass__Alternatives_9 )*
-            loop74:
+            // InternalRoom.g:6510:1: ( rule__DataClass__Alternatives_9 )*
+            loop75:
             do {
-                int alt74=2;
-                int LA74_0 = input.LA(1);
+                int alt75=2;
+                int LA75_0 = input.LA(1);
 
-                if ( ((LA74_0>=14 && LA74_0<=15)||LA74_0==61||LA74_0==64||LA74_0==128) ) {
-                    alt74=1;
+                if ( ((LA75_0>=14 && LA75_0<=15)||LA75_0==61||LA75_0==64||LA75_0==128) ) {
+                    alt75=1;
                 }
 
 
-                switch (alt74) {
+                switch (alt75) {
             	case 1 :
-            	    // InternalRoom.g:6463:2: rule__DataClass__Alternatives_9
+            	    // InternalRoom.g:6510:2: rule__DataClass__Alternatives_9
             	    {
             	    pushFollow(FOLLOW_26);
             	    rule__DataClass__Alternatives_9();
@@ -19426,7 +19582,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop74;
+            	    break loop75;
                 }
             } while (true);
 
@@ -19453,14 +19609,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:6520: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:6524:1: ( rule__DataClass__Group__10__Impl )
+            // InternalRoom.g:6525:2: rule__DataClass__Group__10__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group__10__Impl();
@@ -19486,17 +19642,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__Group__10__Impl"
-    // InternalRoom.g:6484:1: rule__DataClass__Group__10__Impl : ( '}' ) ;
+    // InternalRoom.g:6531: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:6535:1: ( ( '}' ) )
+            // InternalRoom.g:6536:1: ( '}' )
             {
-            // InternalRoom.g:6489:1: ( '}' )
-            // InternalRoom.g:6490:1: '}'
+            // InternalRoom.g:6536:1: ( '}' )
+            // InternalRoom.g:6537:1: '}'
             {
              before(grammarAccess.getDataClassAccess().getRightCurlyBracketKeyword_10()); 
             match(input,45,FOLLOW_2); 
@@ -19523,14 +19679,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:6572: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:6576:1: ( rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1 )
+            // InternalRoom.g:6577:2: rule__DataClass__Group_3__0__Impl rule__DataClass__Group_3__1
             {
             pushFollow(FOLLOW_3);
             rule__DataClass__Group_3__0__Impl();
@@ -19561,17 +19717,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:6584: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:6588:1: ( ( 'extends' ) )
+            // InternalRoom.g:6589:1: ( 'extends' )
             {
-            // InternalRoom.g:6542:1: ( 'extends' )
-            // InternalRoom.g:6543:1: 'extends'
+            // InternalRoom.g:6589:1: ( 'extends' )
+            // InternalRoom.g:6590:1: 'extends'
             {
              before(grammarAccess.getDataClassAccess().getExtendsKeyword_3_0()); 
             match(input,57,FOLLOW_2); 
@@ -19598,14 +19754,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:6603: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:6607:1: ( rule__DataClass__Group_3__1__Impl )
+            // InternalRoom.g:6608:2: rule__DataClass__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_3__1__Impl();
@@ -19631,21 +19787,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:6614: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:6618:1: ( ( ( rule__DataClass__BaseAssignment_3_1 ) ) )
+            // InternalRoom.g:6619: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:6619:1: ( ( rule__DataClass__BaseAssignment_3_1 ) )
+            // InternalRoom.g:6620: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:6621:1: ( rule__DataClass__BaseAssignment_3_1 )
+            // InternalRoom.g:6621:2: rule__DataClass__BaseAssignment_3_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__BaseAssignment_3_1();
@@ -19678,14 +19834,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:6635: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:6639:1: ( rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1 )
+            // InternalRoom.g:6640:2: rule__DataClass__Group_6__0__Impl rule__DataClass__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_6__0__Impl();
@@ -19716,17 +19872,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:6647: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:6651:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:6652:1: ( 'usercode1' )
             {
-            // InternalRoom.g:6605:1: ( 'usercode1' )
-            // InternalRoom.g:6606:1: 'usercode1'
+            // InternalRoom.g:6652:1: ( 'usercode1' )
+            // InternalRoom.g:6653:1: 'usercode1'
             {
              before(grammarAccess.getDataClassAccess().getUsercode1Keyword_6_0()); 
             match(input,58,FOLLOW_2); 
@@ -19753,14 +19909,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:6666: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:6670:1: ( rule__DataClass__Group_6__1__Impl )
+            // InternalRoom.g:6671:2: rule__DataClass__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_6__1__Impl();
@@ -19786,21 +19942,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:6677: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:6681:1: ( ( ( rule__DataClass__UserCode1Assignment_6_1 ) ) )
+            // InternalRoom.g:6682: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:6682:1: ( ( rule__DataClass__UserCode1Assignment_6_1 ) )
+            // InternalRoom.g:6683: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:6684:1: ( rule__DataClass__UserCode1Assignment_6_1 )
+            // InternalRoom.g:6684:2: rule__DataClass__UserCode1Assignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode1Assignment_6_1();
@@ -19833,14 +19989,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:6698: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:6702:1: ( rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1 )
+            // InternalRoom.g:6703:2: rule__DataClass__Group_7__0__Impl rule__DataClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_7__0__Impl();
@@ -19871,17 +20027,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:6710: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:6714:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:6715:1: ( 'usercode2' )
             {
-            // InternalRoom.g:6668:1: ( 'usercode2' )
-            // InternalRoom.g:6669:1: 'usercode2'
+            // InternalRoom.g:6715:1: ( 'usercode2' )
+            // InternalRoom.g:6716:1: 'usercode2'
             {
              before(grammarAccess.getDataClassAccess().getUsercode2Keyword_7_0()); 
             match(input,59,FOLLOW_2); 
@@ -19908,14 +20064,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:6729: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:6733:1: ( rule__DataClass__Group_7__1__Impl )
+            // InternalRoom.g:6734:2: rule__DataClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_7__1__Impl();
@@ -19941,21 +20097,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:6740: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:6744:1: ( ( ( rule__DataClass__UserCode2Assignment_7_1 ) ) )
+            // InternalRoom.g:6745: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:6745:1: ( ( rule__DataClass__UserCode2Assignment_7_1 ) )
+            // InternalRoom.g:6746: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:6747:1: ( rule__DataClass__UserCode2Assignment_7_1 )
+            // InternalRoom.g:6747:2: rule__DataClass__UserCode2Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode2Assignment_7_1();
@@ -19988,14 +20144,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:6761: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:6765:1: ( rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1 )
+            // InternalRoom.g:6766:2: rule__DataClass__Group_8__0__Impl rule__DataClass__Group_8__1
             {
             pushFollow(FOLLOW_27);
             rule__DataClass__Group_8__0__Impl();
@@ -20026,17 +20182,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:6773: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:6777:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:6778:1: ( 'usercode3' )
             {
-            // InternalRoom.g:6731:1: ( 'usercode3' )
-            // InternalRoom.g:6732:1: 'usercode3'
+            // InternalRoom.g:6778:1: ( 'usercode3' )
+            // InternalRoom.g:6779:1: 'usercode3'
             {
              before(grammarAccess.getDataClassAccess().getUsercode3Keyword_8_0()); 
             match(input,60,FOLLOW_2); 
@@ -20063,14 +20219,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:6792: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:6796:1: ( rule__DataClass__Group_8__1__Impl )
+            // InternalRoom.g:6797:2: rule__DataClass__Group_8__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__Group_8__1__Impl();
@@ -20096,21 +20252,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:6803: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:6807:1: ( ( ( rule__DataClass__UserCode3Assignment_8_1 ) ) )
+            // InternalRoom.g:6808: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:6808:1: ( ( rule__DataClass__UserCode3Assignment_8_1 ) )
+            // InternalRoom.g:6809: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:6810:1: ( rule__DataClass__UserCode3Assignment_8_1 )
+            // InternalRoom.g:6810:2: rule__DataClass__UserCode3Assignment_8_1
             {
             pushFollow(FOLLOW_2);
             rule__DataClass__UserCode3Assignment_8_1();
@@ -20143,14 +20299,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:6824: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:6828:1: ( rule__Attribute__Group__0__Impl rule__Attribute__Group__1 )
+            // InternalRoom.g:6829:2: rule__Attribute__Group__0__Impl rule__Attribute__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Attribute__Group__0__Impl();
@@ -20181,17 +20337,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:6836: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:6840:1: ( ( 'Attribute' ) )
+            // InternalRoom.g:6841:1: ( 'Attribute' )
             {
-            // InternalRoom.g:6794:1: ( 'Attribute' )
-            // InternalRoom.g:6795:1: 'Attribute'
+            // InternalRoom.g:6841:1: ( 'Attribute' )
+            // InternalRoom.g:6842:1: 'Attribute'
             {
              before(grammarAccess.getAttributeAccess().getAttributeKeyword_0()); 
             match(input,61,FOLLOW_2); 
@@ -20218,14 +20374,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:6855: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:6859:1: ( rule__Attribute__Group__1__Impl rule__Attribute__Group__2 )
+            // InternalRoom.g:6860:2: rule__Attribute__Group__1__Impl rule__Attribute__Group__2
             {
             pushFollow(FOLLOW_28);
             rule__Attribute__Group__1__Impl();
@@ -20256,21 +20412,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:6867: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:6871:1: ( ( ( rule__Attribute__NameAssignment_1 ) ) )
+            // InternalRoom.g:6872:1: ( ( rule__Attribute__NameAssignment_1 ) )
             {
-            // InternalRoom.g:6825:1: ( ( rule__Attribute__NameAssignment_1 ) )
-            // InternalRoom.g:6826:1: ( rule__Attribute__NameAssignment_1 )
+            // InternalRoom.g:6872:1: ( ( rule__Attribute__NameAssignment_1 ) )
+            // InternalRoom.g:6873: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:6874:1: ( rule__Attribute__NameAssignment_1 )
+            // InternalRoom.g:6874:2: rule__Attribute__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__NameAssignment_1();
@@ -20303,14 +20459,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:6884: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:6888:1: ( rule__Attribute__Group__2__Impl rule__Attribute__Group__3 )
+            // InternalRoom.g:6889:2: rule__Attribute__Group__2__Impl rule__Attribute__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__Attribute__Group__2__Impl();
@@ -20341,29 +20497,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:6896: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:6900:1: ( ( ( rule__Attribute__Group_2__0 )? ) )
+            // InternalRoom.g:6901: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:6901:1: ( ( rule__Attribute__Group_2__0 )? )
+            // InternalRoom.g:6902: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:6903:1: ( rule__Attribute__Group_2__0 )?
+            int alt76=2;
+            int LA76_0 = input.LA(1);
 
-            if ( (LA75_0==62) ) {
-                alt75=1;
+            if ( (LA76_0==62) ) {
+                alt76=1;
             }
-            switch (alt75) {
+            switch (alt76) {
                 case 1 :
-                    // InternalRoom.g:6856:2: rule__Attribute__Group_2__0
+                    // InternalRoom.g:6903:2: rule__Attribute__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__Group_2__0();
@@ -20399,14 +20555,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:6913: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:6917:1: ( rule__Attribute__Group__3__Impl rule__Attribute__Group__4 )
+            // InternalRoom.g:6918:2: rule__Attribute__Group__3__Impl rule__Attribute__Group__4
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__3__Impl();
@@ -20437,17 +20593,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__Group__3__Impl"
-    // InternalRoom.g:6878:1: rule__Attribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:6925: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:6929:1: ( ( ':' ) )
+            // InternalRoom.g:6930:1: ( ':' )
             {
-            // InternalRoom.g:6883:1: ( ':' )
-            // InternalRoom.g:6884:1: ':'
+            // InternalRoom.g:6930:1: ( ':' )
+            // InternalRoom.g:6931:1: ':'
             {
              before(grammarAccess.getAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -20474,14 +20630,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:6944: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:6948:1: ( rule__Attribute__Group__4__Impl rule__Attribute__Group__5 )
+            // InternalRoom.g:6949:2: rule__Attribute__Group__4__Impl rule__Attribute__Group__5
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__4__Impl();
@@ -20512,29 +20668,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:6956: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:6960:1: ( ( ( rule__Attribute__TypeAssignment_4 )? ) )
+            // InternalRoom.g:6961:1: ( ( rule__Attribute__TypeAssignment_4 )? )
             {
-            // InternalRoom.g:6914:1: ( ( rule__Attribute__TypeAssignment_4 )? )
-            // InternalRoom.g:6915:1: ( rule__Attribute__TypeAssignment_4 )?
+            // InternalRoom.g:6961:1: ( ( rule__Attribute__TypeAssignment_4 )? )
+            // InternalRoom.g:6962: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:6963:1: ( rule__Attribute__TypeAssignment_4 )?
+            int alt77=2;
+            int LA77_0 = input.LA(1);
 
-            if ( (LA76_0==RULE_ID) ) {
-                alt76=1;
+            if ( (LA77_0==RULE_ID) ) {
+                alt77=1;
             }
-            switch (alt76) {
+            switch (alt77) {
                 case 1 :
-                    // InternalRoom.g:6916:2: rule__Attribute__TypeAssignment_4
+                    // InternalRoom.g:6963:2: rule__Attribute__TypeAssignment_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__TypeAssignment_4();
@@ -20570,14 +20726,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:6973: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:6977:1: ( rule__Attribute__Group__5__Impl rule__Attribute__Group__6 )
+            // InternalRoom.g:6978:2: rule__Attribute__Group__5__Impl rule__Attribute__Group__6
             {
             pushFollow(FOLLOW_29);
             rule__Attribute__Group__5__Impl();
@@ -20608,29 +20764,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:6985: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:6989:1: ( ( ( rule__Attribute__Group_5__0 )? ) )
+            // InternalRoom.g:6990: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:6990:1: ( ( rule__Attribute__Group_5__0 )? )
+            // InternalRoom.g:6991: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:6992:1: ( rule__Attribute__Group_5__0 )?
+            int alt78=2;
+            int LA78_0 = input.LA(1);
 
-            if ( (LA77_0==55) ) {
-                alt77=1;
+            if ( (LA78_0==55) ) {
+                alt78=1;
             }
-            switch (alt77) {
+            switch (alt78) {
                 case 1 :
-                    // InternalRoom.g:6945:2: rule__Attribute__Group_5__0
+                    // InternalRoom.g:6992:2: rule__Attribute__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__Group_5__0();
@@ -20666,14 +20822,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:7002: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:7006:1: ( rule__Attribute__Group__6__Impl )
+            // InternalRoom.g:7007:2: rule__Attribute__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group__6__Impl();
@@ -20699,29 +20855,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:7013: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:7017:1: ( ( ( rule__Attribute__DocuAssignment_6 )? ) )
+            // InternalRoom.g:7018:1: ( ( rule__Attribute__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:6971:1: ( ( rule__Attribute__DocuAssignment_6 )? )
-            // InternalRoom.g:6972:1: ( rule__Attribute__DocuAssignment_6 )?
+            // InternalRoom.g:7018:1: ( ( rule__Attribute__DocuAssignment_6 )? )
+            // InternalRoom.g:7019: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:7020:1: ( rule__Attribute__DocuAssignment_6 )?
+            int alt79=2;
+            int LA79_0 = input.LA(1);
 
-            if ( (LA78_0==62) ) {
-                alt78=1;
+            if ( (LA79_0==62) ) {
+                alt79=1;
             }
-            switch (alt78) {
+            switch (alt79) {
                 case 1 :
-                    // InternalRoom.g:6973:2: rule__Attribute__DocuAssignment_6
+                    // InternalRoom.g:7020:2: rule__Attribute__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__Attribute__DocuAssignment_6();
@@ -20757,14 +20913,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:7044: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:7048:1: ( rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1 )
+            // InternalRoom.g:7049:2: rule__Attribute__Group_2__0__Impl rule__Attribute__Group_2__1
             {
             pushFollow(FOLLOW_30);
             rule__Attribute__Group_2__0__Impl();
@@ -20795,17 +20951,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:7056: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:7060:1: ( ( '[' ) )
+            // InternalRoom.g:7061:1: ( '[' )
             {
-            // InternalRoom.g:7014:1: ( '[' )
-            // InternalRoom.g:7015:1: '['
+            // InternalRoom.g:7061:1: ( '[' )
+            // InternalRoom.g:7062:1: '['
             {
              before(grammarAccess.getAttributeAccess().getLeftSquareBracketKeyword_2_0()); 
             match(input,62,FOLLOW_2); 
@@ -20832,14 +20988,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:7075: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:7079:1: ( rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2 )
+            // InternalRoom.g:7080:2: rule__Attribute__Group_2__1__Impl rule__Attribute__Group_2__2
             {
             pushFollow(FOLLOW_31);
             rule__Attribute__Group_2__1__Impl();
@@ -20870,21 +21026,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:7087: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:7091:1: ( ( ( rule__Attribute__SizeAssignment_2_1 ) ) )
+            // InternalRoom.g:7092: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:7092:1: ( ( rule__Attribute__SizeAssignment_2_1 ) )
+            // InternalRoom.g:7093: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:7094:1: ( rule__Attribute__SizeAssignment_2_1 )
+            // InternalRoom.g:7094:2: rule__Attribute__SizeAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__SizeAssignment_2_1();
@@ -20917,14 +21073,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:7104: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:7108:1: ( rule__Attribute__Group_2__2__Impl )
+            // InternalRoom.g:7109:2: rule__Attribute__Group_2__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group_2__2__Impl();
@@ -20950,17 +21106,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:7115: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:7119:1: ( ( ']' ) )
+            // InternalRoom.g:7120:1: ( ']' )
             {
-            // InternalRoom.g:7073:1: ( ']' )
-            // InternalRoom.g:7074:1: ']'
+            // InternalRoom.g:7120:1: ( ']' )
+            // InternalRoom.g:7121:1: ']'
             {
              before(grammarAccess.getAttributeAccess().getRightSquareBracketKeyword_2_2()); 
             match(input,63,FOLLOW_2); 
@@ -20987,14 +21143,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:7140: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:7144:1: ( rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1 )
+            // InternalRoom.g:7145:2: rule__Attribute__Group_5__0__Impl rule__Attribute__Group_5__1
             {
             pushFollow(FOLLOW_12);
             rule__Attribute__Group_5__0__Impl();
@@ -21025,17 +21181,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:7152: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:7156:1: ( ( '=' ) )
+            // InternalRoom.g:7157:1: ( '=' )
             {
-            // InternalRoom.g:7110:1: ( '=' )
-            // InternalRoom.g:7111:1: '='
+            // InternalRoom.g:7157:1: ( '=' )
+            // InternalRoom.g:7158:1: '='
             {
              before(grammarAccess.getAttributeAccess().getEqualsSignKeyword_5_0()); 
             match(input,55,FOLLOW_2); 
@@ -21062,14 +21218,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:7171: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:7175:1: ( rule__Attribute__Group_5__1__Impl )
+            // InternalRoom.g:7176:2: rule__Attribute__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__Group_5__1__Impl();
@@ -21095,21 +21251,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:7182: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:7186:1: ( ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) ) )
+            // InternalRoom.g:7187: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:7187:1: ( ( rule__Attribute__DefaultValueLiteralAssignment_5_1 ) )
+            // InternalRoom.g:7188: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:7189:1: ( rule__Attribute__DefaultValueLiteralAssignment_5_1 )
+            // InternalRoom.g:7189:2: rule__Attribute__DefaultValueLiteralAssignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__Attribute__DefaultValueLiteralAssignment_5_1();
@@ -21142,14 +21298,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:7203: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:7207:1: ( rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1 )
+            // InternalRoom.g:7208:2: rule__StandardOperation__Group__0__Impl rule__StandardOperation__Group__1
             {
             pushFollow(FOLLOW_32);
             rule__StandardOperation__Group__0__Impl();
@@ -21180,29 +21336,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:7215: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:7219:1: ( ( ( rule__StandardOperation__OverrideAssignment_0 )? ) )
+            // InternalRoom.g:7220:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
             {
-            // InternalRoom.g:7173:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
-            // InternalRoom.g:7174:1: ( rule__StandardOperation__OverrideAssignment_0 )?
+            // InternalRoom.g:7220:1: ( ( rule__StandardOperation__OverrideAssignment_0 )? )
+            // InternalRoom.g:7221: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:7222:1: ( rule__StandardOperation__OverrideAssignment_0 )?
+            int alt80=2;
+            int LA80_0 = input.LA(1);
 
-            if ( (LA79_0==128) ) {
-                alt79=1;
+            if ( (LA80_0==128) ) {
+                alt80=1;
             }
-            switch (alt79) {
+            switch (alt80) {
                 case 1 :
-                    // InternalRoom.g:7175:2: rule__StandardOperation__OverrideAssignment_0
+                    // InternalRoom.g:7222:2: rule__StandardOperation__OverrideAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__OverrideAssignment_0();
@@ -21238,14 +21394,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:7232: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:7236:1: ( rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2 )
+            // InternalRoom.g:7237:2: rule__StandardOperation__Group__1__Impl rule__StandardOperation__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__StandardOperation__Group__1__Impl();
@@ -21276,17 +21432,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:7244: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:7248:1: ( ( 'Operation' ) )
+            // InternalRoom.g:7249:1: ( 'Operation' )
             {
-            // InternalRoom.g:7202:1: ( 'Operation' )
-            // InternalRoom.g:7203:1: 'Operation'
+            // InternalRoom.g:7249:1: ( 'Operation' )
+            // InternalRoom.g:7250:1: 'Operation'
             {
              before(grammarAccess.getStandardOperationAccess().getOperationKeyword_1()); 
             match(input,64,FOLLOW_2); 
@@ -21313,14 +21469,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:7263: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:7267:1: ( rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3 )
+            // InternalRoom.g:7268:2: rule__StandardOperation__Group__2__Impl rule__StandardOperation__Group__3
             {
             pushFollow(FOLLOW_33);
             rule__StandardOperation__Group__2__Impl();
@@ -21351,21 +21507,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:7275: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:7279:1: ( ( ( rule__StandardOperation__NameAssignment_2 ) ) )
+            // InternalRoom.g:7280:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
             {
-            // InternalRoom.g:7233:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
-            // InternalRoom.g:7234:1: ( rule__StandardOperation__NameAssignment_2 )
+            // InternalRoom.g:7280:1: ( ( rule__StandardOperation__NameAssignment_2 ) )
+            // InternalRoom.g:7281: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:7282:1: ( rule__StandardOperation__NameAssignment_2 )
+            // InternalRoom.g:7282:2: rule__StandardOperation__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__NameAssignment_2();
@@ -21398,14 +21554,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:7292: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:7296:1: ( rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4 )
+            // InternalRoom.g:7297:2: rule__StandardOperation__Group__3__Impl rule__StandardOperation__Group__4
             {
             pushFollow(FOLLOW_34);
             rule__StandardOperation__Group__3__Impl();
@@ -21436,17 +21592,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__3__Impl"
-    // InternalRoom.g:7257:1: rule__StandardOperation__Group__3__Impl : ( '(' ) ;
+    // InternalRoom.g:7304: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:7308:1: ( ( '(' ) )
+            // InternalRoom.g:7309:1: ( '(' )
             {
-            // InternalRoom.g:7262:1: ( '(' )
-            // InternalRoom.g:7263:1: '('
+            // InternalRoom.g:7309:1: ( '(' )
+            // InternalRoom.g:7310:1: '('
             {
              before(grammarAccess.getStandardOperationAccess().getLeftParenthesisKeyword_3()); 
             match(input,50,FOLLOW_2); 
@@ -21473,14 +21629,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:7323: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:7327:1: ( rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5 )
+            // InternalRoom.g:7328:2: rule__StandardOperation__Group__4__Impl rule__StandardOperation__Group__5
             {
             pushFollow(FOLLOW_34);
             rule__StandardOperation__Group__4__Impl();
@@ -21511,29 +21667,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:7335: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:7339:1: ( ( ( rule__StandardOperation__Group_4__0 )? ) )
+            // InternalRoom.g:7340: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:7340:1: ( ( rule__StandardOperation__Group_4__0 )? )
+            // InternalRoom.g:7341: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:7342:1: ( rule__StandardOperation__Group_4__0 )?
+            int alt81=2;
+            int LA81_0 = input.LA(1);
 
-            if ( (LA80_0==RULE_ID) ) {
-                alt80=1;
+            if ( (LA81_0==RULE_ID) ) {
+                alt81=1;
             }
-            switch (alt80) {
+            switch (alt81) {
                 case 1 :
-                    // InternalRoom.g:7295:2: rule__StandardOperation__Group_4__0
+                    // InternalRoom.g:7342:2: rule__StandardOperation__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__Group_4__0();
@@ -21569,14 +21725,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:7352: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:7356:1: ( rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6 )
+            // InternalRoom.g:7357:2: rule__StandardOperation__Group__5__Impl rule__StandardOperation__Group__6
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__5__Impl();
@@ -21607,17 +21763,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__Group__5__Impl"
-    // InternalRoom.g:7317:1: rule__StandardOperation__Group__5__Impl : ( ')' ) ;
+    // InternalRoom.g:7364: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:7368:1: ( ( ')' ) )
+            // InternalRoom.g:7369:1: ( ')' )
             {
-            // InternalRoom.g:7322:1: ( ')' )
-            // InternalRoom.g:7323:1: ')'
+            // InternalRoom.g:7369:1: ( ')' )
+            // InternalRoom.g:7370:1: ')'
             {
              before(grammarAccess.getStandardOperationAccess().getRightParenthesisKeyword_5()); 
             match(input,51,FOLLOW_2); 
@@ -21644,14 +21800,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:7383: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:7387:1: ( rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7 )
+            // InternalRoom.g:7388:2: rule__StandardOperation__Group__6__Impl rule__StandardOperation__Group__7
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__6__Impl();
@@ -21682,29 +21838,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:7395: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:7399:1: ( ( ( rule__StandardOperation__Group_6__0 )? ) )
+            // InternalRoom.g:7400: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:7400:1: ( ( rule__StandardOperation__Group_6__0 )? )
+            // InternalRoom.g:7401: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:7402:1: ( rule__StandardOperation__Group_6__0 )?
+            int alt82=2;
+            int LA82_0 = input.LA(1);
 
-            if ( (LA81_0==46) ) {
-                alt81=1;
+            if ( (LA82_0==46) ) {
+                alt82=1;
             }
-            switch (alt81) {
+            switch (alt82) {
                 case 1 :
-                    // InternalRoom.g:7355:2: rule__StandardOperation__Group_6__0
+                    // InternalRoom.g:7402:2: rule__StandardOperation__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__Group_6__0();
@@ -21740,14 +21896,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:7412: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:7416:1: ( rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8 )
+            // InternalRoom.g:7417:2: rule__StandardOperation__Group__7__Impl rule__StandardOperation__Group__8
             {
             pushFollow(FOLLOW_35);
             rule__StandardOperation__Group__7__Impl();
@@ -21778,29 +21934,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:7424: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:7428:1: ( ( ( rule__StandardOperation__DocuAssignment_7 )? ) )
+            // InternalRoom.g:7429:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
             {
-            // InternalRoom.g:7382:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
-            // InternalRoom.g:7383:1: ( rule__StandardOperation__DocuAssignment_7 )?
+            // InternalRoom.g:7429:1: ( ( rule__StandardOperation__DocuAssignment_7 )? )
+            // InternalRoom.g:7430: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:7431:1: ( rule__StandardOperation__DocuAssignment_7 )?
+            int alt83=2;
+            int LA83_0 = input.LA(1);
 
-            if ( (LA82_0==62) ) {
-                alt82=1;
+            if ( (LA83_0==62) ) {
+                alt83=1;
             }
-            switch (alt82) {
+            switch (alt83) {
                 case 1 :
-                    // InternalRoom.g:7384:2: rule__StandardOperation__DocuAssignment_7
+                    // InternalRoom.g:7431:2: rule__StandardOperation__DocuAssignment_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__StandardOperation__DocuAssignment_7();
@@ -21836,14 +21992,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:7441: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:7445:1: ( rule__StandardOperation__Group__8__Impl )
+            // InternalRoom.g:7446:2: rule__StandardOperation__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group__8__Impl();
@@ -21869,21 +22025,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:7452: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:7456:1: ( ( ( rule__StandardOperation__DetailCodeAssignment_8 ) ) )
+            // InternalRoom.g:7457:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
             {
-            // InternalRoom.g:7410:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
-            // InternalRoom.g:7411:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
+            // InternalRoom.g:7457:1: ( ( rule__StandardOperation__DetailCodeAssignment_8 ) )
+            // InternalRoom.g:7458: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:7459:1: ( rule__StandardOperation__DetailCodeAssignment_8 )
+            // InternalRoom.g:7459:2: rule__StandardOperation__DetailCodeAssignment_8
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__DetailCodeAssignment_8();
@@ -21916,14 +22072,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:7487: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:7491:1: ( rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1 )
+            // InternalRoom.g:7492:2: rule__StandardOperation__Group_4__0__Impl rule__StandardOperation__Group_4__1
             {
             pushFollow(FOLLOW_18);
             rule__StandardOperation__Group_4__0__Impl();
@@ -21954,21 +22110,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:7499: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:7503:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) ) )
+            // InternalRoom.g:7504: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:7504:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_0 ) )
+            // InternalRoom.g:7505: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:7506:1: ( rule__StandardOperation__ArgumentsAssignment_4_0 )
+            // InternalRoom.g:7506:2: rule__StandardOperation__ArgumentsAssignment_4_0
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__ArgumentsAssignment_4_0();
@@ -22001,14 +22157,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:7516: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:7520:1: ( rule__StandardOperation__Group_4__1__Impl )
+            // InternalRoom.g:7521:2: rule__StandardOperation__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_4__1__Impl();
@@ -22034,33 +22190,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:7527: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:7531:1: ( ( ( rule__StandardOperation__Group_4_1__0 )* ) )
+            // InternalRoom.g:7532: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:7532:1: ( ( rule__StandardOperation__Group_4_1__0 )* )
+            // InternalRoom.g:7533: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:7534:1: ( rule__StandardOperation__Group_4_1__0 )*
+            loop84:
             do {
-                int alt83=2;
-                int LA83_0 = input.LA(1);
+                int alt84=2;
+                int LA84_0 = input.LA(1);
 
-                if ( (LA83_0==54) ) {
-                    alt83=1;
+                if ( (LA84_0==54) ) {
+                    alt84=1;
                 }
 
 
-                switch (alt83) {
+                switch (alt84) {
             	case 1 :
-            	    // InternalRoom.g:7487:2: rule__StandardOperation__Group_4_1__0
+            	    // InternalRoom.g:7534:2: rule__StandardOperation__Group_4_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__StandardOperation__Group_4_1__0();
@@ -22072,7 +22228,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop83;
+            	    break loop84;
                 }
             } while (true);
 
@@ -22099,14 +22255,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:7548: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:7552:1: ( rule__StandardOperation__Group_4_1__0__Impl rule__StandardOperation__Group_4_1__1 )
+            // InternalRoom.g:7553: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 +22293,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:7560: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:7564:1: ( ( ',' ) )
+            // InternalRoom.g:7565:1: ( ',' )
             {
-            // InternalRoom.g:7518:1: ( ',' )
-            // InternalRoom.g:7519:1: ','
+            // InternalRoom.g:7565:1: ( ',' )
+            // InternalRoom.g:7566:1: ','
             {
              before(grammarAccess.getStandardOperationAccess().getCommaKeyword_4_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -22174,14 +22330,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:7579: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:7583:1: ( rule__StandardOperation__Group_4_1__1__Impl )
+            // InternalRoom.g:7584:2: rule__StandardOperation__Group_4_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_4_1__1__Impl();
@@ -22207,21 +22363,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:7590: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:7594:1: ( ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) ) )
+            // InternalRoom.g:7595: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:7595:1: ( ( rule__StandardOperation__ArgumentsAssignment_4_1_1 ) )
+            // InternalRoom.g:7596: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:7597:1: ( rule__StandardOperation__ArgumentsAssignment_4_1_1 )
+            // InternalRoom.g:7597:2: rule__StandardOperation__ArgumentsAssignment_4_1_1
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__ArgumentsAssignment_4_1_1();
@@ -22254,14 +22410,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:7611: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:7615:1: ( rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1 )
+            // InternalRoom.g:7616:2: rule__StandardOperation__Group_6__0__Impl rule__StandardOperation__Group_6__1
             {
             pushFollow(FOLLOW_36);
             rule__StandardOperation__Group_6__0__Impl();
@@ -22292,17 +22448,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:7623: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:7627:1: ( ( ':' ) )
+            // InternalRoom.g:7628:1: ( ':' )
             {
-            // InternalRoom.g:7581:1: ( ':' )
-            // InternalRoom.g:7582:1: ':'
+            // InternalRoom.g:7628:1: ( ':' )
+            // InternalRoom.g:7629:1: ':'
             {
              before(grammarAccess.getStandardOperationAccess().getColonKeyword_6_0()); 
             match(input,46,FOLLOW_2); 
@@ -22329,14 +22485,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:7642: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:7646:1: ( rule__StandardOperation__Group_6__1__Impl )
+            // InternalRoom.g:7647:2: rule__StandardOperation__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Group_6__1__Impl();
@@ -22362,21 +22518,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:7653: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:7657:1: ( ( ( rule__StandardOperation__Alternatives_6_1 ) ) )
+            // InternalRoom.g:7658: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:7658:1: ( ( rule__StandardOperation__Alternatives_6_1 ) )
+            // InternalRoom.g:7659: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:7660:1: ( rule__StandardOperation__Alternatives_6_1 )
+            // InternalRoom.g:7660:2: rule__StandardOperation__Alternatives_6_1
             {
             pushFollow(FOLLOW_2);
             rule__StandardOperation__Alternatives_6_1();
@@ -22409,14 +22565,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:7674: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:7678:1: ( rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1 )
+            // InternalRoom.g:7679:2: rule__PortOperation__Group__0__Impl rule__PortOperation__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__PortOperation__Group__0__Impl();
@@ -22447,17 +22603,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:7686: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:7690:1: ( ( 'Operation' ) )
+            // InternalRoom.g:7691:1: ( 'Operation' )
             {
-            // InternalRoom.g:7644:1: ( 'Operation' )
-            // InternalRoom.g:7645:1: 'Operation'
+            // InternalRoom.g:7691:1: ( 'Operation' )
+            // InternalRoom.g:7692:1: 'Operation'
             {
              before(grammarAccess.getPortOperationAccess().getOperationKeyword_0()); 
             match(input,64,FOLLOW_2); 
@@ -22484,14 +22640,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:7705: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:7709:1: ( rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2 )
+            // InternalRoom.g:7710:2: rule__PortOperation__Group__1__Impl rule__PortOperation__Group__2
             {
             pushFollow(FOLLOW_33);
             rule__PortOperation__Group__1__Impl();
@@ -22522,21 +22678,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:7717: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:7721:1: ( ( ( rule__PortOperation__NameAssignment_1 ) ) )
+            // InternalRoom.g:7722:1: ( ( rule__PortOperation__NameAssignment_1 ) )
             {
-            // InternalRoom.g:7675:1: ( ( rule__PortOperation__NameAssignment_1 ) )
-            // InternalRoom.g:7676:1: ( rule__PortOperation__NameAssignment_1 )
+            // InternalRoom.g:7722:1: ( ( rule__PortOperation__NameAssignment_1 ) )
+            // InternalRoom.g:7723: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:7724:1: ( rule__PortOperation__NameAssignment_1 )
+            // InternalRoom.g:7724:2: rule__PortOperation__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__NameAssignment_1();
@@ -22569,14 +22725,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:7734: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:7738:1: ( rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3 )
+            // InternalRoom.g:7739:2: rule__PortOperation__Group__2__Impl rule__PortOperation__Group__3
             {
             pushFollow(FOLLOW_34);
             rule__PortOperation__Group__2__Impl();
@@ -22607,17 +22763,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__2__Impl"
-    // InternalRoom.g:7699:1: rule__PortOperation__Group__2__Impl : ( '(' ) ;
+    // InternalRoom.g:7746: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:7750:1: ( ( '(' ) )
+            // InternalRoom.g:7751:1: ( '(' )
             {
-            // InternalRoom.g:7704:1: ( '(' )
-            // InternalRoom.g:7705:1: '('
+            // InternalRoom.g:7751:1: ( '(' )
+            // InternalRoom.g:7752:1: '('
             {
              before(grammarAccess.getPortOperationAccess().getLeftParenthesisKeyword_2()); 
             match(input,50,FOLLOW_2); 
@@ -22644,14 +22800,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:7765: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:7769:1: ( rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4 )
+            // InternalRoom.g:7770:2: rule__PortOperation__Group__3__Impl rule__PortOperation__Group__4
             {
             pushFollow(FOLLOW_34);
             rule__PortOperation__Group__3__Impl();
@@ -22682,29 +22838,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:7777: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:7781:1: ( ( ( rule__PortOperation__Group_3__0 )? ) )
+            // InternalRoom.g:7782: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:7782:1: ( ( rule__PortOperation__Group_3__0 )? )
+            // InternalRoom.g:7783: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:7784:1: ( rule__PortOperation__Group_3__0 )?
+            int alt85=2;
+            int LA85_0 = input.LA(1);
 
-            if ( (LA84_0==RULE_ID) ) {
-                alt84=1;
+            if ( (LA85_0==RULE_ID) ) {
+                alt85=1;
             }
-            switch (alt84) {
+            switch (alt85) {
                 case 1 :
-                    // InternalRoom.g:7737:2: rule__PortOperation__Group_3__0
+                    // InternalRoom.g:7784:2: rule__PortOperation__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Group_3__0();
@@ -22740,14 +22896,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:7794: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:7798:1: ( rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5 )
+            // InternalRoom.g:7799:2: rule__PortOperation__Group__4__Impl rule__PortOperation__Group__5
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__4__Impl();
@@ -22778,17 +22934,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__Group__4__Impl"
-    // InternalRoom.g:7759:1: rule__PortOperation__Group__4__Impl : ( ')' ) ;
+    // InternalRoom.g:7806: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:7810:1: ( ( ')' ) )
+            // InternalRoom.g:7811:1: ( ')' )
             {
-            // InternalRoom.g:7764:1: ( ')' )
-            // InternalRoom.g:7765:1: ')'
+            // InternalRoom.g:7811:1: ( ')' )
+            // InternalRoom.g:7812:1: ')'
             {
              before(grammarAccess.getPortOperationAccess().getRightParenthesisKeyword_4()); 
             match(input,51,FOLLOW_2); 
@@ -22815,14 +22971,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:7825: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:7829:1: ( rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6 )
+            // InternalRoom.g:7830:2: rule__PortOperation__Group__5__Impl rule__PortOperation__Group__6
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__5__Impl();
@@ -22853,29 +23009,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:7837: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:7841:1: ( ( ( rule__PortOperation__Alternatives_5 )? ) )
+            // InternalRoom.g:7842:1: ( ( rule__PortOperation__Alternatives_5 )? )
             {
-            // InternalRoom.g:7795:1: ( ( rule__PortOperation__Alternatives_5 )? )
-            // InternalRoom.g:7796:1: ( rule__PortOperation__Alternatives_5 )?
+            // InternalRoom.g:7842:1: ( ( rule__PortOperation__Alternatives_5 )? )
+            // InternalRoom.g:7843: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:7844:1: ( rule__PortOperation__Alternatives_5 )?
+            int alt86=2;
+            int LA86_0 = input.LA(1);
 
-            if ( (LA85_0==46||LA85_0==65) ) {
-                alt85=1;
+            if ( (LA86_0==46||LA86_0==65) ) {
+                alt86=1;
             }
-            switch (alt85) {
+            switch (alt86) {
                 case 1 :
-                    // InternalRoom.g:7797:2: rule__PortOperation__Alternatives_5
+                    // InternalRoom.g:7844:2: rule__PortOperation__Alternatives_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__Alternatives_5();
@@ -22911,14 +23067,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:7854: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:7858:1: ( rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7 )
+            // InternalRoom.g:7859:2: rule__PortOperation__Group__6__Impl rule__PortOperation__Group__7
             {
             pushFollow(FOLLOW_37);
             rule__PortOperation__Group__6__Impl();
@@ -22949,29 +23105,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:7866: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:7870:1: ( ( ( rule__PortOperation__DocuAssignment_6 )? ) )
+            // InternalRoom.g:7871:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:7824:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
-            // InternalRoom.g:7825:1: ( rule__PortOperation__DocuAssignment_6 )?
+            // InternalRoom.g:7871:1: ( ( rule__PortOperation__DocuAssignment_6 )? )
+            // InternalRoom.g:7872: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:7873:1: ( rule__PortOperation__DocuAssignment_6 )?
+            int alt87=2;
+            int LA87_0 = input.LA(1);
 
-            if ( (LA86_0==62) ) {
-                alt86=1;
+            if ( (LA87_0==62) ) {
+                alt87=1;
             }
-            switch (alt86) {
+            switch (alt87) {
                 case 1 :
-                    // InternalRoom.g:7826:2: rule__PortOperation__DocuAssignment_6
+                    // InternalRoom.g:7873:2: rule__PortOperation__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortOperation__DocuAssignment_6();
@@ -23007,14 +23163,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:7883: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:7887:1: ( rule__PortOperation__Group__7__Impl )
+            // InternalRoom.g:7888:2: rule__PortOperation__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group__7__Impl();
@@ -23040,21 +23196,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:7894: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:7898:1: ( ( ( rule__PortOperation__DetailCodeAssignment_7 ) ) )
+            // InternalRoom.g:7899:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
             {
-            // InternalRoom.g:7852:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
-            // InternalRoom.g:7853:1: ( rule__PortOperation__DetailCodeAssignment_7 )
+            // InternalRoom.g:7899:1: ( ( rule__PortOperation__DetailCodeAssignment_7 ) )
+            // InternalRoom.g:7900: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:7901:1: ( rule__PortOperation__DetailCodeAssignment_7 )
+            // InternalRoom.g:7901:2: rule__PortOperation__DetailCodeAssignment_7
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__DetailCodeAssignment_7();
@@ -23087,14 +23243,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:7927: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:7931:1: ( rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1 )
+            // InternalRoom.g:7932:2: rule__PortOperation__Group_3__0__Impl rule__PortOperation__Group_3__1
             {
             pushFollow(FOLLOW_18);
             rule__PortOperation__Group_3__0__Impl();
@@ -23125,21 +23281,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:7939: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:7943:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) ) )
+            // InternalRoom.g:7944: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:7944:1: ( ( rule__PortOperation__ArgumentsAssignment_3_0 ) )
+            // InternalRoom.g:7945: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:7946:1: ( rule__PortOperation__ArgumentsAssignment_3_0 )
+            // InternalRoom.g:7946:2: rule__PortOperation__ArgumentsAssignment_3_0
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__ArgumentsAssignment_3_0();
@@ -23172,14 +23328,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:7956: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:7960:1: ( rule__PortOperation__Group_3__1__Impl )
+            // InternalRoom.g:7961:2: rule__PortOperation__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_3__1__Impl();
@@ -23205,33 +23361,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:7967: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:7971:1: ( ( ( rule__PortOperation__Group_3_1__0 )* ) )
+            // InternalRoom.g:7972: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:7972:1: ( ( rule__PortOperation__Group_3_1__0 )* )
+            // InternalRoom.g:7973: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:7974:1: ( rule__PortOperation__Group_3_1__0 )*
+            loop88:
             do {
-                int alt87=2;
-                int LA87_0 = input.LA(1);
+                int alt88=2;
+                int LA88_0 = input.LA(1);
 
-                if ( (LA87_0==54) ) {
-                    alt87=1;
+                if ( (LA88_0==54) ) {
+                    alt88=1;
                 }
 
 
-                switch (alt87) {
+                switch (alt88) {
             	case 1 :
-            	    // InternalRoom.g:7927:2: rule__PortOperation__Group_3_1__0
+            	    // InternalRoom.g:7974:2: rule__PortOperation__Group_3_1__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__PortOperation__Group_3_1__0();
@@ -23243,7 +23399,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop87;
+            	    break loop88;
                 }
             } while (true);
 
@@ -23270,14 +23426,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:7988: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:7992:1: ( rule__PortOperation__Group_3_1__0__Impl rule__PortOperation__Group_3_1__1 )
+            // InternalRoom.g:7993: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 +23464,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:8000: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:8004:1: ( ( ',' ) )
+            // InternalRoom.g:8005:1: ( ',' )
             {
-            // InternalRoom.g:7958:1: ( ',' )
-            // InternalRoom.g:7959:1: ','
+            // InternalRoom.g:8005:1: ( ',' )
+            // InternalRoom.g:8006:1: ','
             {
              before(grammarAccess.getPortOperationAccess().getCommaKeyword_3_1_0()); 
             match(input,54,FOLLOW_2); 
@@ -23345,14 +23501,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:8019: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:8023:1: ( rule__PortOperation__Group_3_1__1__Impl )
+            // InternalRoom.g:8024:2: rule__PortOperation__Group_3_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_3_1__1__Impl();
@@ -23378,21 +23534,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:8030: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:8034:1: ( ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) ) )
+            // InternalRoom.g:8035: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:8035:1: ( ( rule__PortOperation__ArgumentsAssignment_3_1_1 ) )
+            // InternalRoom.g:8036: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:8037:1: ( rule__PortOperation__ArgumentsAssignment_3_1_1 )
+            // InternalRoom.g:8037:2: rule__PortOperation__ArgumentsAssignment_3_1_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__ArgumentsAssignment_3_1_1();
@@ -23425,14 +23581,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:8051: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:8055:1: ( rule__PortOperation__Group_5_0__0__Impl rule__PortOperation__Group_5_0__1 )
+            // InternalRoom.g:8056: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 +23619,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:8063: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:8067:1: ( ( ':' ) )
+            // InternalRoom.g:8068:1: ( ':' )
             {
-            // InternalRoom.g:8021:1: ( ':' )
-            // InternalRoom.g:8022:1: ':'
+            // InternalRoom.g:8068:1: ( ':' )
+            // InternalRoom.g:8069:1: ':'
             {
              before(grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0()); 
             match(input,46,FOLLOW_2); 
@@ -23500,14 +23656,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:8082: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:8086:1: ( rule__PortOperation__Group_5_0__1__Impl )
+            // InternalRoom.g:8087:2: rule__PortOperation__Group_5_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_5_0__1__Impl();
@@ -23533,21 +23689,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:8093: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:8097:1: ( ( ( rule__PortOperation__Alternatives_5_0_1 ) ) )
+            // InternalRoom.g:8098: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:8098:1: ( ( rule__PortOperation__Alternatives_5_0_1 ) )
+            // InternalRoom.g:8099: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:8100:1: ( rule__PortOperation__Alternatives_5_0_1 )
+            // InternalRoom.g:8100:2: rule__PortOperation__Alternatives_5_0_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Alternatives_5_0_1();
@@ -23580,14 +23736,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:8114: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:8118:1: ( rule__PortOperation__Group_5_1__0__Impl rule__PortOperation__Group_5_1__1 )
+            // InternalRoom.g:8119: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 +23774,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:8126: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:8130:1: ( ( 'sends' ) )
+            // InternalRoom.g:8131:1: ( 'sends' )
             {
-            // InternalRoom.g:8084:1: ( 'sends' )
-            // InternalRoom.g:8085:1: 'sends'
+            // InternalRoom.g:8131:1: ( 'sends' )
+            // InternalRoom.g:8132:1: 'sends'
             {
              before(grammarAccess.getPortOperationAccess().getSendsKeyword_5_1_0()); 
             match(input,65,FOLLOW_2); 
@@ -23655,14 +23811,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:8145: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:8149:1: ( rule__PortOperation__Group_5_1__1__Impl )
+            // InternalRoom.g:8150:2: rule__PortOperation__Group_5_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__Group_5_1__1__Impl();
@@ -23688,21 +23844,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:8156: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:8160:1: ( ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) ) )
+            // InternalRoom.g:8161: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:8161:1: ( ( rule__PortOperation__SendsMsgAssignment_5_1_1 ) )
+            // InternalRoom.g:8162: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:8163:1: ( rule__PortOperation__SendsMsgAssignment_5_1_1 )
+            // InternalRoom.g:8163:2: rule__PortOperation__SendsMsgAssignment_5_1_1
             {
             pushFollow(FOLLOW_2);
             rule__PortOperation__SendsMsgAssignment_5_1_1();
@@ -23735,14 +23891,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:8177: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:8181:1: ( rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1 )
+            // InternalRoom.g:8182:2: rule__ClassStructor__Group__0__Impl rule__ClassStructor__Group__1
             {
             pushFollow(FOLLOW_27);
             rule__ClassStructor__Group__0__Impl();
@@ -23773,21 +23929,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:8189: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:8193:1: ( ( ( rule__ClassStructor__NameAssignment_0 ) ) )
+            // InternalRoom.g:8194:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
             {
-            // InternalRoom.g:8147:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
-            // InternalRoom.g:8148:1: ( rule__ClassStructor__NameAssignment_0 )
+            // InternalRoom.g:8194:1: ( ( rule__ClassStructor__NameAssignment_0 ) )
+            // InternalRoom.g:8195: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:8196:1: ( rule__ClassStructor__NameAssignment_0 )
+            // InternalRoom.g:8196:2: rule__ClassStructor__NameAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__NameAssignment_0();
@@ -23820,14 +23976,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:8206: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:8210:1: ( rule__ClassStructor__Group__1__Impl )
+            // InternalRoom.g:8211:2: rule__ClassStructor__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__Group__1__Impl();
@@ -23853,21 +24009,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:8217: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:8221:1: ( ( ( rule__ClassStructor__DetailCodeAssignment_1 ) ) )
+            // InternalRoom.g:8222:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
             {
-            // InternalRoom.g:8175:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
-            // InternalRoom.g:8176:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
+            // InternalRoom.g:8222:1: ( ( rule__ClassStructor__DetailCodeAssignment_1 ) )
+            // InternalRoom.g:8223: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:8224:1: ( rule__ClassStructor__DetailCodeAssignment_1 )
+            // InternalRoom.g:8224:2: rule__ClassStructor__DetailCodeAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__DetailCodeAssignment_1();
@@ -23900,14 +24056,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:8238: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:8242:1: ( rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1 )
+            // InternalRoom.g:8243:2: rule__ProtocolClass__Group__0__Impl rule__ProtocolClass__Group__1
             {
             pushFollow(FOLLOW_38);
             rule__ProtocolClass__Group__0__Impl();
@@ -23938,29 +24094,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:8250: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:8254:1: ( ( ( rule__ProtocolClass__CommTypeAssignment_0 )? ) )
+            // InternalRoom.g:8255:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
             {
-            // InternalRoom.g:8208:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
-            // InternalRoom.g:8209:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
+            // InternalRoom.g:8255:1: ( ( rule__ProtocolClass__CommTypeAssignment_0 )? )
+            // InternalRoom.g:8256: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:8257:1: ( rule__ProtocolClass__CommTypeAssignment_0 )?
+            int alt89=2;
+            int LA89_0 = input.LA(1);
 
-            if ( ((LA88_0>=33 && LA88_0<=35)) ) {
-                alt88=1;
+            if ( ((LA89_0>=33 && LA89_0<=35)) ) {
+                alt89=1;
             }
-            switch (alt88) {
+            switch (alt89) {
                 case 1 :
-                    // InternalRoom.g:8210:2: rule__ProtocolClass__CommTypeAssignment_0
+                    // InternalRoom.g:8257:2: rule__ProtocolClass__CommTypeAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__CommTypeAssignment_0();
@@ -23996,14 +24152,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:8267: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:8271:1: ( rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2 )
+            // InternalRoom.g:8272:2: rule__ProtocolClass__Group__1__Impl rule__ProtocolClass__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ProtocolClass__Group__1__Impl();
@@ -24034,17 +24190,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:8279: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:8283:1: ( ( 'ProtocolClass' ) )
+            // InternalRoom.g:8284:1: ( 'ProtocolClass' )
             {
-            // InternalRoom.g:8237:1: ( 'ProtocolClass' )
-            // InternalRoom.g:8238:1: 'ProtocolClass'
+            // InternalRoom.g:8284:1: ( 'ProtocolClass' )
+            // InternalRoom.g:8285:1: 'ProtocolClass'
             {
              before(grammarAccess.getProtocolClassAccess().getProtocolClassKeyword_1()); 
             match(input,20,FOLLOW_2); 
@@ -24071,14 +24227,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:8298: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:8302:1: ( rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3 )
+            // InternalRoom.g:8303:2: rule__ProtocolClass__Group__2__Impl rule__ProtocolClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__2__Impl();
@@ -24109,21 +24265,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:8310: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:8314:1: ( ( ( rule__ProtocolClass__NameAssignment_2 ) ) )
+            // InternalRoom.g:8315:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
             {
-            // InternalRoom.g:8268:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
-            // InternalRoom.g:8269:1: ( rule__ProtocolClass__NameAssignment_2 )
+            // InternalRoom.g:8315:1: ( ( rule__ProtocolClass__NameAssignment_2 ) )
+            // InternalRoom.g:8316: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:8317:1: ( rule__ProtocolClass__NameAssignment_2 )
+            // InternalRoom.g:8317:2: rule__ProtocolClass__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__NameAssignment_2();
@@ -24156,14 +24312,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:8327: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:8331:1: ( rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4 )
+            // InternalRoom.g:8332:2: rule__ProtocolClass__Group__3__Impl rule__ProtocolClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__3__Impl();
@@ -24194,29 +24350,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:8339: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:8343:1: ( ( ( rule__ProtocolClass__DocuAssignment_3 )? ) )
+            // InternalRoom.g:8344:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
             {
-            // InternalRoom.g:8297:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
-            // InternalRoom.g:8298:1: ( rule__ProtocolClass__DocuAssignment_3 )?
+            // InternalRoom.g:8344:1: ( ( rule__ProtocolClass__DocuAssignment_3 )? )
+            // InternalRoom.g:8345: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:8346:1: ( rule__ProtocolClass__DocuAssignment_3 )?
+            int alt90=2;
+            int LA90_0 = input.LA(1);
 
-            if ( (LA89_0==62) ) {
-                alt89=1;
+            if ( (LA90_0==62) ) {
+                alt90=1;
             }
-            switch (alt89) {
+            switch (alt90) {
                 case 1 :
-                    // InternalRoom.g:8299:2: rule__ProtocolClass__DocuAssignment_3
+                    // InternalRoom.g:8346:2: rule__ProtocolClass__DocuAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__DocuAssignment_3();
@@ -24252,14 +24408,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:8356: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:8360:1: ( rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5 )
+            // InternalRoom.g:8361:2: rule__ProtocolClass__Group__4__Impl rule__ProtocolClass__Group__5
             {
             pushFollow(FOLLOW_23);
             rule__ProtocolClass__Group__4__Impl();
@@ -24290,29 +24446,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:8368: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:8372:1: ( ( ( rule__ProtocolClass__Group_4__0 )? ) )
+            // InternalRoom.g:8373: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:8373:1: ( ( rule__ProtocolClass__Group_4__0 )? )
+            // InternalRoom.g:8374: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:8375:1: ( rule__ProtocolClass__Group_4__0 )?
+            int alt91=2;
+            int LA91_0 = input.LA(1);
 
-            if ( (LA90_0==57) ) {
-                alt90=1;
+            if ( (LA91_0==57) ) {
+                alt91=1;
             }
-            switch (alt90) {
+            switch (alt91) {
                 case 1 :
-                    // InternalRoom.g:8328:2: rule__ProtocolClass__Group_4__0
+                    // InternalRoom.g:8375:2: rule__ProtocolClass__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_4__0();
@@ -24348,14 +24504,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:8385: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:8389:1: ( rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6 )
+            // InternalRoom.g:8390:2: rule__ProtocolClass__Group__5__Impl rule__ProtocolClass__Group__6
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__5__Impl();
@@ -24386,17 +24542,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__5__Impl"
-    // InternalRoom.g:8350:1: rule__ProtocolClass__Group__5__Impl : ( '{' ) ;
+    // InternalRoom.g:8397: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:8401:1: ( ( '{' ) )
+            // InternalRoom.g:8402:1: ( '{' )
             {
-            // InternalRoom.g:8355:1: ( '{' )
-            // InternalRoom.g:8356:1: '{'
+            // InternalRoom.g:8402:1: ( '{' )
+            // InternalRoom.g:8403:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_5()); 
             match(input,44,FOLLOW_2); 
@@ -24423,14 +24579,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:8416: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:8420:1: ( rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7 )
+            // InternalRoom.g:8421:2: rule__ProtocolClass__Group__6__Impl rule__ProtocolClass__Group__7
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__6__Impl();
@@ -24461,33 +24617,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:8428: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:8432:1: ( ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:8433:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:8386:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:8387:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
+            // InternalRoom.g:8433:1: ( ( rule__ProtocolClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:8434:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getProtocolClassAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:8388:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
-            loop91:
+            // InternalRoom.g:8435:1: ( rule__ProtocolClass__AnnotationsAssignment_6 )*
+            loop92:
             do {
-                int alt91=2;
-                int LA91_0 = input.LA(1);
+                int alt92=2;
+                int LA92_0 = input.LA(1);
 
-                if ( (LA91_0==121) ) {
-                    alt91=1;
+                if ( (LA92_0==121) ) {
+                    alt92=1;
                 }
 
 
-                switch (alt91) {
+                switch (alt92) {
             	case 1 :
-            	    // InternalRoom.g:8388:2: rule__ProtocolClass__AnnotationsAssignment_6
+            	    // InternalRoom.g:8435:2: rule__ProtocolClass__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ProtocolClass__AnnotationsAssignment_6();
@@ -24499,7 +24655,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop91;
+            	    break loop92;
                 }
             } while (true);
 
@@ -24526,14 +24682,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:8445: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:8449:1: ( rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8 )
+            // InternalRoom.g:8450:2: rule__ProtocolClass__Group__7__Impl rule__ProtocolClass__Group__8
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__7__Impl();
@@ -24564,29 +24720,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:8457: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:8461:1: ( ( ( rule__ProtocolClass__Group_7__0 )? ) )
+            // InternalRoom.g:8462: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:8462:1: ( ( rule__ProtocolClass__Group_7__0 )? )
+            // InternalRoom.g:8463: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:8464:1: ( rule__ProtocolClass__Group_7__0 )?
+            int alt93=2;
+            int LA93_0 = input.LA(1);
 
-            if ( (LA92_0==58) ) {
-                alt92=1;
+            if ( (LA93_0==58) ) {
+                alt93=1;
             }
-            switch (alt92) {
+            switch (alt93) {
                 case 1 :
-                    // InternalRoom.g:8417:2: rule__ProtocolClass__Group_7__0
+                    // InternalRoom.g:8464:2: rule__ProtocolClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_7__0();
@@ -24622,14 +24778,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:8474: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:8478:1: ( rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9 )
+            // InternalRoom.g:8479:2: rule__ProtocolClass__Group__8__Impl rule__ProtocolClass__Group__9
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__8__Impl();
@@ -24660,29 +24816,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:8486: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:8490:1: ( ( ( rule__ProtocolClass__Group_8__0 )? ) )
+            // InternalRoom.g:8491: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:8491:1: ( ( rule__ProtocolClass__Group_8__0 )? )
+            // InternalRoom.g:8492: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:8493:1: ( rule__ProtocolClass__Group_8__0 )?
+            int alt94=2;
+            int LA94_0 = input.LA(1);
 
-            if ( (LA93_0==59) ) {
-                alt93=1;
+            if ( (LA94_0==59) ) {
+                alt94=1;
             }
-            switch (alt93) {
+            switch (alt94) {
                 case 1 :
-                    // InternalRoom.g:8446:2: rule__ProtocolClass__Group_8__0
+                    // InternalRoom.g:8493:2: rule__ProtocolClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_8__0();
@@ -24718,14 +24874,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:8503: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:8507:1: ( rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10 )
+            // InternalRoom.g:8508:2: rule__ProtocolClass__Group__9__Impl rule__ProtocolClass__Group__10
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__9__Impl();
@@ -24756,29 +24912,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:8515: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:8519:1: ( ( ( rule__ProtocolClass__Group_9__0 )? ) )
+            // InternalRoom.g:8520: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:8520:1: ( ( rule__ProtocolClass__Group_9__0 )? )
+            // InternalRoom.g:8521: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:8522:1: ( rule__ProtocolClass__Group_9__0 )?
+            int alt95=2;
+            int LA95_0 = input.LA(1);
 
-            if ( (LA94_0==60) ) {
-                alt94=1;
+            if ( (LA95_0==60) ) {
+                alt95=1;
             }
-            switch (alt94) {
+            switch (alt95) {
                 case 1 :
-                    // InternalRoom.g:8475:2: rule__ProtocolClass__Group_9__0
+                    // InternalRoom.g:8522:2: rule__ProtocolClass__Group_9__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_9__0();
@@ -24814,14 +24970,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:8532: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:8536:1: ( rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11 )
+            // InternalRoom.g:8537:2: rule__ProtocolClass__Group__10__Impl rule__ProtocolClass__Group__11
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__10__Impl();
@@ -24852,29 +25008,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:8544: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:8548:1: ( ( ( rule__ProtocolClass__Group_10__0 )? ) )
+            // InternalRoom.g:8549: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:8549:1: ( ( rule__ProtocolClass__Group_10__0 )? )
+            // InternalRoom.g:8550: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:8551:1: ( rule__ProtocolClass__Group_10__0 )?
+            int alt96=2;
+            int LA96_0 = input.LA(1);
 
-            if ( (LA95_0==66) ) {
-                alt95=1;
+            if ( (LA96_0==66) ) {
+                alt96=1;
             }
-            switch (alt95) {
+            switch (alt96) {
                 case 1 :
-                    // InternalRoom.g:8504:2: rule__ProtocolClass__Group_10__0
+                    // InternalRoom.g:8551:2: rule__ProtocolClass__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_10__0();
@@ -24910,14 +25066,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:8561: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:8565:1: ( rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12 )
+            // InternalRoom.g:8566:2: rule__ProtocolClass__Group__11__Impl rule__ProtocolClass__Group__12
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__11__Impl();
@@ -24948,29 +25104,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:8573: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:8577:1: ( ( ( rule__ProtocolClass__Group_11__0 )? ) )
+            // InternalRoom.g:8578: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:8578:1: ( ( rule__ProtocolClass__Group_11__0 )? )
+            // InternalRoom.g:8579: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:8580:1: ( rule__ProtocolClass__Group_11__0 )?
+            int alt97=2;
+            int LA97_0 = input.LA(1);
 
-            if ( (LA96_0==67) ) {
-                alt96=1;
+            if ( (LA97_0==67) ) {
+                alt97=1;
             }
-            switch (alt96) {
+            switch (alt97) {
                 case 1 :
-                    // InternalRoom.g:8533:2: rule__ProtocolClass__Group_11__0
+                    // InternalRoom.g:8580:2: rule__ProtocolClass__Group_11__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_11__0();
@@ -25006,14 +25162,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:8590: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:8594:1: ( rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13 )
+            // InternalRoom.g:8595:2: rule__ProtocolClass__Group__12__Impl rule__ProtocolClass__Group__13
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__12__Impl();
@@ -25044,29 +25200,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:8602: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:8606:1: ( ( ( rule__ProtocolClass__Group_12__0 )? ) )
+            // InternalRoom.g:8607: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:8607:1: ( ( rule__ProtocolClass__Group_12__0 )? )
+            // InternalRoom.g:8608: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:8609:1: ( rule__ProtocolClass__Group_12__0 )?
+            int alt98=2;
+            int LA98_0 = input.LA(1);
 
-            if ( (LA97_0==68) ) {
-                alt97=1;
+            if ( (LA98_0==68) ) {
+                alt98=1;
             }
-            switch (alt97) {
+            switch (alt98) {
                 case 1 :
-                    // InternalRoom.g:8562:2: rule__ProtocolClass__Group_12__0
+                    // InternalRoom.g:8609:2: rule__ProtocolClass__Group_12__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_12__0();
@@ -25102,14 +25258,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:8619: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:8623:1: ( rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14 )
+            // InternalRoom.g:8624:2: rule__ProtocolClass__Group__13__Impl rule__ProtocolClass__Group__14
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__13__Impl();
@@ -25140,29 +25296,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:8631: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:8635:1: ( ( ( rule__ProtocolClass__Group_13__0 )? ) )
+            // InternalRoom.g:8636: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:8636:1: ( ( rule__ProtocolClass__Group_13__0 )? )
+            // InternalRoom.g:8637: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:8638:1: ( rule__ProtocolClass__Group_13__0 )?
+            int alt99=2;
+            int LA99_0 = input.LA(1);
 
-            if ( (LA98_0==70) ) {
-                alt98=1;
+            if ( (LA99_0==70) ) {
+                alt99=1;
             }
-            switch (alt98) {
+            switch (alt99) {
                 case 1 :
-                    // InternalRoom.g:8591:2: rule__ProtocolClass__Group_13__0
+                    // InternalRoom.g:8638:2: rule__ProtocolClass__Group_13__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__Group_13__0();
@@ -25198,14 +25354,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:8648: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:8652:1: ( rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15 )
+            // InternalRoom.g:8653:2: rule__ProtocolClass__Group__14__Impl rule__ProtocolClass__Group__15
             {
             pushFollow(FOLLOW_39);
             rule__ProtocolClass__Group__14__Impl();
@@ -25236,29 +25392,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:8660: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:8664:1: ( ( ( rule__ProtocolClass__SemanticsAssignment_14 )? ) )
+            // InternalRoom.g:8665:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
             {
-            // InternalRoom.g:8618:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
-            // InternalRoom.g:8619:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
+            // InternalRoom.g:8665:1: ( ( rule__ProtocolClass__SemanticsAssignment_14 )? )
+            // InternalRoom.g:8666: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:8667:1: ( rule__ProtocolClass__SemanticsAssignment_14 )?
+            int alt100=2;
+            int LA100_0 = input.LA(1);
 
-            if ( (LA99_0==118) ) {
-                alt99=1;
+            if ( (LA100_0==118) ) {
+                alt100=1;
             }
-            switch (alt99) {
+            switch (alt100) {
                 case 1 :
-                    // InternalRoom.g:8620:2: rule__ProtocolClass__SemanticsAssignment_14
+                    // InternalRoom.g:8667:2: rule__ProtocolClass__SemanticsAssignment_14
                     {
                     pushFollow(FOLLOW_2);
                     rule__ProtocolClass__SemanticsAssignment_14();
@@ -25294,14 +25450,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:8677: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:8681:1: ( rule__ProtocolClass__Group__15__Impl )
+            // InternalRoom.g:8682:2: rule__ProtocolClass__Group__15__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group__15__Impl();
@@ -25327,17 +25483,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__Group__15__Impl"
-    // InternalRoom.g:8641:1: rule__ProtocolClass__Group__15__Impl : ( '}' ) ;
+    // InternalRoom.g:8688: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:8692:1: ( ( '}' ) )
+            // InternalRoom.g:8693:1: ( '}' )
             {
-            // InternalRoom.g:8646:1: ( '}' )
-            // InternalRoom.g:8647:1: '}'
+            // InternalRoom.g:8693:1: ( '}' )
+            // InternalRoom.g:8694:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_15()); 
             match(input,45,FOLLOW_2); 
@@ -25364,14 +25520,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:8739: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:8743:1: ( rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1 )
+            // InternalRoom.g:8744:2: rule__ProtocolClass__Group_4__0__Impl rule__ProtocolClass__Group_4__1
             {
             pushFollow(FOLLOW_3);
             rule__ProtocolClass__Group_4__0__Impl();
@@ -25402,17 +25558,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:8751: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:8755:1: ( ( 'extends' ) )
+            // InternalRoom.g:8756:1: ( 'extends' )
             {
-            // InternalRoom.g:8709:1: ( 'extends' )
-            // InternalRoom.g:8710:1: 'extends'
+            // InternalRoom.g:8756:1: ( 'extends' )
+            // InternalRoom.g:8757:1: 'extends'
             {
              before(grammarAccess.getProtocolClassAccess().getExtendsKeyword_4_0()); 
             match(input,57,FOLLOW_2); 
@@ -25439,14 +25595,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:8770: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:8774:1: ( rule__ProtocolClass__Group_4__1__Impl )
+            // InternalRoom.g:8775:2: rule__ProtocolClass__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_4__1__Impl();
@@ -25472,21 +25628,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:8781: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:8785:1: ( ( ( rule__ProtocolClass__BaseAssignment_4_1 ) ) )
+            // InternalRoom.g:8786: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:8786:1: ( ( rule__ProtocolClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:8787: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:8788:1: ( rule__ProtocolClass__BaseAssignment_4_1 )
+            // InternalRoom.g:8788:2: rule__ProtocolClass__BaseAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__BaseAssignment_4_1();
@@ -25519,14 +25675,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:8802: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:8806:1: ( rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1 )
+            // InternalRoom.g:8807:2: rule__ProtocolClass__Group_7__0__Impl rule__ProtocolClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_7__0__Impl();
@@ -25557,17 +25713,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:8814: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:8818:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:8819:1: ( 'usercode1' )
             {
-            // InternalRoom.g:8772:1: ( 'usercode1' )
-            // InternalRoom.g:8773:1: 'usercode1'
+            // InternalRoom.g:8819:1: ( 'usercode1' )
+            // InternalRoom.g:8820:1: 'usercode1'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode1Keyword_7_0()); 
             match(input,58,FOLLOW_2); 
@@ -25594,14 +25750,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:8833: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:8837:1: ( rule__ProtocolClass__Group_7__1__Impl )
+            // InternalRoom.g:8838:2: rule__ProtocolClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_7__1__Impl();
@@ -25627,21 +25783,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:8844: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:8848:1: ( ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) ) )
+            // InternalRoom.g:8849: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:8849:1: ( ( rule__ProtocolClass__UserCode1Assignment_7_1 ) )
+            // InternalRoom.g:8850: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:8851:1: ( rule__ProtocolClass__UserCode1Assignment_7_1 )
+            // InternalRoom.g:8851:2: rule__ProtocolClass__UserCode1Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode1Assignment_7_1();
@@ -25674,14 +25830,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:8865: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:8869:1: ( rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1 )
+            // InternalRoom.g:8870:2: rule__ProtocolClass__Group_8__0__Impl rule__ProtocolClass__Group_8__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_8__0__Impl();
@@ -25712,17 +25868,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:8877: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:8881:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:8882:1: ( 'usercode2' )
             {
-            // InternalRoom.g:8835:1: ( 'usercode2' )
-            // InternalRoom.g:8836:1: 'usercode2'
+            // InternalRoom.g:8882:1: ( 'usercode2' )
+            // InternalRoom.g:8883:1: 'usercode2'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode2Keyword_8_0()); 
             match(input,59,FOLLOW_2); 
@@ -25749,14 +25905,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:8896: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:8900:1: ( rule__ProtocolClass__Group_8__1__Impl )
+            // InternalRoom.g:8901:2: rule__ProtocolClass__Group_8__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_8__1__Impl();
@@ -25782,21 +25938,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:8907: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:8911:1: ( ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) ) )
+            // InternalRoom.g:8912: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:8912:1: ( ( rule__ProtocolClass__UserCode2Assignment_8_1 ) )
+            // InternalRoom.g:8913: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:8914:1: ( rule__ProtocolClass__UserCode2Assignment_8_1 )
+            // InternalRoom.g:8914:2: rule__ProtocolClass__UserCode2Assignment_8_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode2Assignment_8_1();
@@ -25829,14 +25985,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:8928: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:8932:1: ( rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1 )
+            // InternalRoom.g:8933:2: rule__ProtocolClass__Group_9__0__Impl rule__ProtocolClass__Group_9__1
             {
             pushFollow(FOLLOW_27);
             rule__ProtocolClass__Group_9__0__Impl();
@@ -25867,17 +26023,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:8940: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:8944:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:8945:1: ( 'usercode3' )
             {
-            // InternalRoom.g:8898:1: ( 'usercode3' )
-            // InternalRoom.g:8899:1: 'usercode3'
+            // InternalRoom.g:8945:1: ( 'usercode3' )
+            // InternalRoom.g:8946:1: 'usercode3'
             {
              before(grammarAccess.getProtocolClassAccess().getUsercode3Keyword_9_0()); 
             match(input,60,FOLLOW_2); 
@@ -25904,14 +26060,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:8959: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:8963:1: ( rule__ProtocolClass__Group_9__1__Impl )
+            // InternalRoom.g:8964:2: rule__ProtocolClass__Group_9__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_9__1__Impl();
@@ -25937,21 +26093,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:8970: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:8974:1: ( ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) ) )
+            // InternalRoom.g:8975: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:8975:1: ( ( rule__ProtocolClass__UserCode3Assignment_9_1 ) )
+            // InternalRoom.g:8976: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:8977:1: ( rule__ProtocolClass__UserCode3Assignment_9_1 )
+            // InternalRoom.g:8977:2: rule__ProtocolClass__UserCode3Assignment_9_1
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__UserCode3Assignment_9_1();
@@ -25984,14 +26140,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:8991: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:8995:1: ( rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1 )
+            // InternalRoom.g:8996:2: rule__ProtocolClass__Group_10__0__Impl rule__ProtocolClass__Group_10__1
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_10__0__Impl();
@@ -26022,17 +26178,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:9003: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:9007:1: ( ( 'incoming' ) )
+            // InternalRoom.g:9008:1: ( 'incoming' )
             {
-            // InternalRoom.g:8961:1: ( 'incoming' )
-            // InternalRoom.g:8962:1: 'incoming'
+            // InternalRoom.g:9008:1: ( 'incoming' )
+            // InternalRoom.g:9009:1: 'incoming'
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingKeyword_10_0()); 
             match(input,66,FOLLOW_2); 
@@ -26059,14 +26215,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:9022: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:9026:1: ( rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2 )
+            // InternalRoom.g:9027:2: rule__ProtocolClass__Group_10__1__Impl rule__ProtocolClass__Group_10__2
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_10__1__Impl();
@@ -26097,17 +26253,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:9034: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:9038:1: ( ( '{' ) )
+            // InternalRoom.g:9039:1: ( '{' )
             {
-            // InternalRoom.g:8992:1: ( '{' )
-            // InternalRoom.g:8993:1: '{'
+            // InternalRoom.g:9039:1: ( '{' )
+            // InternalRoom.g:9040:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1()); 
             match(input,44,FOLLOW_2); 
@@ -26134,14 +26290,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:9053: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:9057:1: ( rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3 )
+            // InternalRoom.g:9058:2: rule__ProtocolClass__Group_10__2__Impl rule__ProtocolClass__Group_10__3
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_10__2__Impl();
@@ -26172,33 +26328,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:9065: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:9069:1: ( ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* ) )
+            // InternalRoom.g:9070: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:9070:1: ( ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )* )
+            // InternalRoom.g:9071:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingMessagesAssignment_10_2()); 
-            // InternalRoom.g:9025:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
-            loop100:
+            // InternalRoom.g:9072:1: ( rule__ProtocolClass__IncomingMessagesAssignment_10_2 )*
+            loop101:
             do {
-                int alt100=2;
-                int LA100_0 = input.LA(1);
+                int alt101=2;
+                int LA101_0 = input.LA(1);
 
-                if ( (LA100_0==25||LA100_0==129) ) {
-                    alt100=1;
+                if ( (LA101_0==25||LA101_0==129) ) {
+                    alt101=1;
                 }
 
 
-                switch (alt100) {
+                switch (alt101) {
             	case 1 :
-            	    // InternalRoom.g:9025:2: rule__ProtocolClass__IncomingMessagesAssignment_10_2
+            	    // InternalRoom.g:9072:2: rule__ProtocolClass__IncomingMessagesAssignment_10_2
             	    {
             	    pushFollow(FOLLOW_42);
             	    rule__ProtocolClass__IncomingMessagesAssignment_10_2();
@@ -26210,7 +26366,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop100;
+            	    break loop101;
                 }
             } while (true);
 
@@ -26237,14 +26393,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:9082: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:9086:1: ( rule__ProtocolClass__Group_10__3__Impl )
+            // InternalRoom.g:9087:2: rule__ProtocolClass__Group_10__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_10__3__Impl();
@@ -26270,17 +26426,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:9093: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:9097:1: ( ( '}' ) )
+            // InternalRoom.g:9098:1: ( '}' )
             {
-            // InternalRoom.g:9051:1: ( '}' )
-            // InternalRoom.g:9052:1: '}'
+            // InternalRoom.g:9098:1: ( '}' )
+            // InternalRoom.g:9099:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_10_3()); 
             match(input,45,FOLLOW_2); 
@@ -26307,14 +26463,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:9120: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:9124:1: ( rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1 )
+            // InternalRoom.g:9125:2: rule__ProtocolClass__Group_11__0__Impl rule__ProtocolClass__Group_11__1
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_11__0__Impl();
@@ -26345,17 +26501,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:9132: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:9136:1: ( ( 'outgoing' ) )
+            // InternalRoom.g:9137:1: ( 'outgoing' )
             {
-            // InternalRoom.g:9090:1: ( 'outgoing' )
-            // InternalRoom.g:9091:1: 'outgoing'
+            // InternalRoom.g:9137:1: ( 'outgoing' )
+            // InternalRoom.g:9138:1: 'outgoing'
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingKeyword_11_0()); 
             match(input,67,FOLLOW_2); 
@@ -26382,14 +26538,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:9151: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:9155:1: ( rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2 )
+            // InternalRoom.g:9156:2: rule__ProtocolClass__Group_11__1__Impl rule__ProtocolClass__Group_11__2
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_11__1__Impl();
@@ -26420,17 +26576,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:9163: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:9167:1: ( ( '{' ) )
+            // InternalRoom.g:9168:1: ( '{' )
             {
-            // InternalRoom.g:9121:1: ( '{' )
-            // InternalRoom.g:9122:1: '{'
+            // InternalRoom.g:9168:1: ( '{' )
+            // InternalRoom.g:9169:1: '{'
             {
              before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1()); 
             match(input,44,FOLLOW_2); 
@@ -26457,14 +26613,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:9182: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:9186:1: ( rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3 )
+            // InternalRoom.g:9187:2: rule__ProtocolClass__Group_11__2__Impl rule__ProtocolClass__Group_11__3
             {
             pushFollow(FOLLOW_41);
             rule__ProtocolClass__Group_11__2__Impl();
@@ -26495,33 +26651,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:9194: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:9198:1: ( ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* ) )
+            // InternalRoom.g:9199: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:9199:1: ( ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )* )
+            // InternalRoom.g:9200:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesAssignment_11_2()); 
-            // InternalRoom.g:9154:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
-            loop101:
+            // InternalRoom.g:9201:1: ( rule__ProtocolClass__OutgoingMessagesAssignment_11_2 )*
+            loop102:
             do {
-                int alt101=2;
-                int LA101_0 = input.LA(1);
+                int alt102=2;
+                int LA102_0 = input.LA(1);
 
-                if ( (LA101_0==25||LA101_0==129) ) {
-                    alt101=1;
+                if ( (LA102_0==25||LA102_0==129) ) {
+                    alt102=1;
                 }
 
 
-                switch (alt101) {
+                switch (alt102) {
             	case 1 :
-            	    // InternalRoom.g:9154:2: rule__ProtocolClass__OutgoingMessagesAssignment_11_2
+            	    // InternalRoom.g:9201:2: rule__ProtocolClass__OutgoingMessagesAssignment_11_2
             	    {
             	    pushFollow(FOLLOW_42);
             	    rule__ProtocolClass__OutgoingMessagesAssignment_11_2();
@@ -26533,7 +26689,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop101;
+            	    break loop102;
                 }
             } while (true);
 
@@ -26560,14 +26716,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:9211: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:9215:1: ( rule__ProtocolClass__Group_11__3__Impl )
+            // InternalRoom.g:9216:2: rule__ProtocolClass__Group_11__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_11__3__Impl();
@@ -26593,17 +26749,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:9222: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:9226:1: ( ( '}' ) )
+            // InternalRoom.g:9227:1: ( '}' )
             {
-            // InternalRoom.g:9180:1: ( '}' )
-            // InternalRoom.g:9181:1: '}'
+            // InternalRoom.g:9227:1: ( '}' )
+            // InternalRoom.g:9228:1: '}'
             {
              before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_11_3()); 
             match(input,45,FOLLOW_2); 
@@ -26630,14 +26786,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:9249: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:9253:1: ( rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1 )
+            // InternalRoom.g:9254:2: rule__ProtocolClass__Group_12__0__Impl rule__ProtocolClass__Group_12__1
             {
             pushFollow(FOLLOW_43);
             rule__ProtocolClass__Group_12__0__Impl();
@@ -26668,17 +26824,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:9261: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:9265:1: ( ( 'regular' ) )
+            // InternalRoom.g:9266:1: ( 'regular' )
             {
-            // InternalRoom.g:9219:1: ( 'regular' )
-            // InternalRoom.g:9220:1: 'regular'
+            // InternalRoom.g:9266:1: ( 'regular' )
+            // InternalRoom.g:9267:1: 'regular'
             {
              before(grammarAccess.getProtocolClassAccess().getRegularKeyword_12_0()); 
             match(input,68,FOLLOW_2); 
@@ -26705,14 +26861,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:9280: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:9284:1: ( rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2 )
+            // InternalRoom.g:9285:2: rule__ProtocolClass__Group_12__1__Impl rule__ProtocolClass__Group_12__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_12__1__Impl();
@@ -26743,17 +26899,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:9292: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:9296:1: ( ( 'PortClass' ) )
+            // InternalRoom.g:9297:1: ( 'PortClass' )
             {
-            // InternalRoom.g:9250:1: ( 'PortClass' )
-            // InternalRoom.g:9251:1: 'PortClass'
+            // InternalRoom.g:9297:1: ( 'PortClass' )
+            // InternalRoom.g:9298:1: 'PortClass'
             {
              before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_12_1()); 
             match(input,69,FOLLOW_2); 
@@ -26780,14 +26936,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:9311: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:9315:1: ( rule__ProtocolClass__Group_12__2__Impl )
+            // InternalRoom.g:9316:2: rule__ProtocolClass__Group_12__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_12__2__Impl();
@@ -26813,21 +26969,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:9322: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:9326:1: ( ( ( rule__ProtocolClass__RegularAssignment_12_2 ) ) )
+            // InternalRoom.g:9327: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:9327:1: ( ( rule__ProtocolClass__RegularAssignment_12_2 ) )
+            // InternalRoom.g:9328: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:9329:1: ( rule__ProtocolClass__RegularAssignment_12_2 )
+            // InternalRoom.g:9329:2: rule__ProtocolClass__RegularAssignment_12_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__RegularAssignment_12_2();
@@ -26860,14 +27016,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:9345: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:9349:1: ( rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1 )
+            // InternalRoom.g:9350:2: rule__ProtocolClass__Group_13__0__Impl rule__ProtocolClass__Group_13__1
             {
             pushFollow(FOLLOW_43);
             rule__ProtocolClass__Group_13__0__Impl();
@@ -26898,17 +27054,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:9357: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:9361:1: ( ( 'conjugated' ) )
+            // InternalRoom.g:9362:1: ( 'conjugated' )
             {
-            // InternalRoom.g:9315:1: ( 'conjugated' )
-            // InternalRoom.g:9316:1: 'conjugated'
+            // InternalRoom.g:9362:1: ( 'conjugated' )
+            // InternalRoom.g:9363:1: 'conjugated'
             {
              before(grammarAccess.getProtocolClassAccess().getConjugatedKeyword_13_0()); 
             match(input,70,FOLLOW_2); 
@@ -26935,14 +27091,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:9376: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:9380:1: ( rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2 )
+            // InternalRoom.g:9381:2: rule__ProtocolClass__Group_13__1__Impl rule__ProtocolClass__Group_13__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolClass__Group_13__1__Impl();
@@ -26973,17 +27129,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:9388: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:9392:1: ( ( 'PortClass' ) )
+            // InternalRoom.g:9393:1: ( 'PortClass' )
             {
-            // InternalRoom.g:9346:1: ( 'PortClass' )
-            // InternalRoom.g:9347:1: 'PortClass'
+            // InternalRoom.g:9393:1: ( 'PortClass' )
+            // InternalRoom.g:9394:1: 'PortClass'
             {
              before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_13_1()); 
             match(input,69,FOLLOW_2); 
@@ -27010,14 +27166,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:9407: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:9411:1: ( rule__ProtocolClass__Group_13__2__Impl )
+            // InternalRoom.g:9412:2: rule__ProtocolClass__Group_13__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__Group_13__2__Impl();
@@ -27043,21 +27199,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:9418: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:9422:1: ( ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) ) )
+            // InternalRoom.g:9423: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:9423:1: ( ( rule__ProtocolClass__ConjugatedAssignment_13_2 ) )
+            // InternalRoom.g:9424: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:9425:1: ( rule__ProtocolClass__ConjugatedAssignment_13_2 )
+            // InternalRoom.g:9425:2: rule__ProtocolClass__ConjugatedAssignment_13_2
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolClass__ConjugatedAssignment_13_2();
@@ -27090,14 +27246,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:9441: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:9445:1: ( rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1 )
+            // InternalRoom.g:9446:2: rule__CompoundProtocolClass__Group__0__Impl rule__CompoundProtocolClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__CompoundProtocolClass__Group__0__Impl();
@@ -27128,17 +27284,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:9453: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:9457:1: ( ( 'CompoundProtocolClass' ) )
+            // InternalRoom.g:9458:1: ( 'CompoundProtocolClass' )
             {
-            // InternalRoom.g:9411:1: ( 'CompoundProtocolClass' )
-            // InternalRoom.g:9412:1: 'CompoundProtocolClass'
+            // InternalRoom.g:9458:1: ( 'CompoundProtocolClass' )
+            // InternalRoom.g:9459:1: 'CompoundProtocolClass'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getCompoundProtocolClassKeyword_0()); 
             match(input,21,FOLLOW_2); 
@@ -27165,14 +27321,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:9472: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:9476:1: ( rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2 )
+            // InternalRoom.g:9477:2: rule__CompoundProtocolClass__Group__1__Impl rule__CompoundProtocolClass__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__CompoundProtocolClass__Group__1__Impl();
@@ -27203,21 +27359,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:9484: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:9488:1: ( ( ( rule__CompoundProtocolClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:9489:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:9442:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
-            // InternalRoom.g:9443:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
+            // InternalRoom.g:9489:1: ( ( rule__CompoundProtocolClass__NameAssignment_1 ) )
+            // InternalRoom.g:9490: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:9491:1: ( rule__CompoundProtocolClass__NameAssignment_1 )
+            // InternalRoom.g:9491:2: rule__CompoundProtocolClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__CompoundProtocolClass__NameAssignment_1();
@@ -27250,14 +27406,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:9501: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:9505:1: ( rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3 )
+            // InternalRoom.g:9506:2: rule__CompoundProtocolClass__Group__2__Impl rule__CompoundProtocolClass__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__CompoundProtocolClass__Group__2__Impl();
@@ -27288,29 +27444,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:9513: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:9517:1: ( ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:9518:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:9471:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
-            // InternalRoom.g:9472:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
+            // InternalRoom.g:9518:1: ( ( rule__CompoundProtocolClass__DocuAssignment_2 )? )
+            // InternalRoom.g:9519: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:9520:1: ( rule__CompoundProtocolClass__DocuAssignment_2 )?
+            int alt103=2;
+            int LA103_0 = input.LA(1);
 
-            if ( (LA102_0==62) ) {
-                alt102=1;
+            if ( (LA103_0==62) ) {
+                alt103=1;
             }
-            switch (alt102) {
+            switch (alt103) {
                 case 1 :
-                    // InternalRoom.g:9473:2: rule__CompoundProtocolClass__DocuAssignment_2
+                    // InternalRoom.g:9520:2: rule__CompoundProtocolClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__CompoundProtocolClass__DocuAssignment_2();
@@ -27346,14 +27502,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:9530: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:9534:1: ( rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4 )
+            // InternalRoom.g:9535:2: rule__CompoundProtocolClass__Group__3__Impl rule__CompoundProtocolClass__Group__4
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__3__Impl();
@@ -27384,17 +27540,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__3__Impl"
-    // InternalRoom.g:9495:1: rule__CompoundProtocolClass__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:9542: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:9546:1: ( ( '{' ) )
+            // InternalRoom.g:9547:1: ( '{' )
             {
-            // InternalRoom.g:9500:1: ( '{' )
-            // InternalRoom.g:9501:1: '{'
+            // InternalRoom.g:9547:1: ( '{' )
+            // InternalRoom.g:9548:1: '{'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -27421,14 +27577,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:9561: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:9565:1: ( rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5 )
+            // InternalRoom.g:9566:2: rule__CompoundProtocolClass__Group__4__Impl rule__CompoundProtocolClass__Group__5
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__4__Impl();
@@ -27459,33 +27615,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:9573: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:9577:1: ( ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:9578:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:9531:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:9532:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
+            // InternalRoom.g:9578:1: ( ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:9579:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:9533:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
-            loop103:
+            // InternalRoom.g:9580:1: ( rule__CompoundProtocolClass__AnnotationsAssignment_4 )*
+            loop104:
             do {
-                int alt103=2;
-                int LA103_0 = input.LA(1);
+                int alt104=2;
+                int LA104_0 = input.LA(1);
 
-                if ( (LA103_0==121) ) {
-                    alt103=1;
+                if ( (LA104_0==121) ) {
+                    alt104=1;
                 }
 
 
-                switch (alt103) {
+                switch (alt104) {
             	case 1 :
-            	    // InternalRoom.g:9533:2: rule__CompoundProtocolClass__AnnotationsAssignment_4
+            	    // InternalRoom.g:9580:2: rule__CompoundProtocolClass__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__CompoundProtocolClass__AnnotationsAssignment_4();
@@ -27497,7 +27653,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop103;
+            	    break loop104;
                 }
             } while (true);
 
@@ -27524,14 +27680,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:9590: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:9594:1: ( rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6 )
+            // InternalRoom.g:9595:2: rule__CompoundProtocolClass__Group__5__Impl rule__CompoundProtocolClass__Group__6
             {
             pushFollow(FOLLOW_44);
             rule__CompoundProtocolClass__Group__5__Impl();
@@ -27562,33 +27718,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:9602: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:9606:1: ( ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* ) )
+            // InternalRoom.g:9607:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
             {
-            // InternalRoom.g:9560:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
-            // InternalRoom.g:9561:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
+            // InternalRoom.g:9607:1: ( ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )* )
+            // InternalRoom.g:9608:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsAssignment_5()); 
-            // InternalRoom.g:9562:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
-            loop104:
+            // InternalRoom.g:9609:1: ( rule__CompoundProtocolClass__SubProtocolsAssignment_5 )*
+            loop105:
             do {
-                int alt104=2;
-                int LA104_0 = input.LA(1);
+                int alt105=2;
+                int LA105_0 = input.LA(1);
 
-                if ( (LA104_0==71) ) {
-                    alt104=1;
+                if ( (LA105_0==71) ) {
+                    alt105=1;
                 }
 
 
-                switch (alt104) {
+                switch (alt105) {
             	case 1 :
-            	    // InternalRoom.g:9562:2: rule__CompoundProtocolClass__SubProtocolsAssignment_5
+            	    // InternalRoom.g:9609:2: rule__CompoundProtocolClass__SubProtocolsAssignment_5
             	    {
             	    pushFollow(FOLLOW_45);
             	    rule__CompoundProtocolClass__SubProtocolsAssignment_5();
@@ -27600,7 +27756,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop104;
+            	    break loop105;
                 }
             } while (true);
 
@@ -27627,14 +27783,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:9619: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:9623:1: ( rule__CompoundProtocolClass__Group__6__Impl )
+            // InternalRoom.g:9624:2: rule__CompoundProtocolClass__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CompoundProtocolClass__Group__6__Impl();
@@ -27660,17 +27816,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__Group__6__Impl"
-    // InternalRoom.g:9583:1: rule__CompoundProtocolClass__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:9630: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:9634:1: ( ( '}' ) )
+            // InternalRoom.g:9635:1: ( '}' )
             {
-            // InternalRoom.g:9588:1: ( '}' )
-            // InternalRoom.g:9589:1: '}'
+            // InternalRoom.g:9635:1: ( '}' )
+            // InternalRoom.g:9636:1: '}'
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -27697,14 +27853,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:9663: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:9667:1: ( rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1 )
+            // InternalRoom.g:9668:2: rule__SubProtocol__Group__0__Impl rule__SubProtocol__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubProtocol__Group__0__Impl();
@@ -27735,17 +27891,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:9675: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:9679:1: ( ( 'SubProtocol' ) )
+            // InternalRoom.g:9680:1: ( 'SubProtocol' )
             {
-            // InternalRoom.g:9633:1: ( 'SubProtocol' )
-            // InternalRoom.g:9634:1: 'SubProtocol'
+            // InternalRoom.g:9680:1: ( 'SubProtocol' )
+            // InternalRoom.g:9681:1: 'SubProtocol'
             {
              before(grammarAccess.getSubProtocolAccess().getSubProtocolKeyword_0()); 
             match(input,71,FOLLOW_2); 
@@ -27772,14 +27928,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:9694: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:9698:1: ( rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2 )
+            // InternalRoom.g:9699:2: rule__SubProtocol__Group__1__Impl rule__SubProtocol__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SubProtocol__Group__1__Impl();
@@ -27810,21 +27966,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:9706: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:9710:1: ( ( ( rule__SubProtocol__NameAssignment_1 ) ) )
+            // InternalRoom.g:9711:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
             {
-            // InternalRoom.g:9664:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
-            // InternalRoom.g:9665:1: ( rule__SubProtocol__NameAssignment_1 )
+            // InternalRoom.g:9711:1: ( ( rule__SubProtocol__NameAssignment_1 ) )
+            // InternalRoom.g:9712: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:9713:1: ( rule__SubProtocol__NameAssignment_1 )
+            // InternalRoom.g:9713:2: rule__SubProtocol__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__NameAssignment_1();
@@ -27857,14 +28013,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:9723: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:9727:1: ( rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3 )
+            // InternalRoom.g:9728:2: rule__SubProtocol__Group__2__Impl rule__SubProtocol__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SubProtocol__Group__2__Impl();
@@ -27895,17 +28051,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__Group__2__Impl"
-    // InternalRoom.g:9688:1: rule__SubProtocol__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:9735: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:9739:1: ( ( ':' ) )
+            // InternalRoom.g:9740:1: ( ':' )
             {
-            // InternalRoom.g:9693:1: ( ':' )
-            // InternalRoom.g:9694:1: ':'
+            // InternalRoom.g:9740:1: ( ':' )
+            // InternalRoom.g:9741:1: ':'
             {
              before(grammarAccess.getSubProtocolAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -27932,14 +28088,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:9754: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:9758:1: ( rule__SubProtocol__Group__3__Impl )
+            // InternalRoom.g:9759:2: rule__SubProtocol__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__Group__3__Impl();
@@ -27965,21 +28121,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:9765: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:9769:1: ( ( ( rule__SubProtocol__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:9770:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:9723:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
-            // InternalRoom.g:9724:1: ( rule__SubProtocol__ProtocolAssignment_3 )
+            // InternalRoom.g:9770:1: ( ( rule__SubProtocol__ProtocolAssignment_3 ) )
+            // InternalRoom.g:9771: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:9772:1: ( rule__SubProtocol__ProtocolAssignment_3 )
+            // InternalRoom.g:9772:2: rule__SubProtocol__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SubProtocol__ProtocolAssignment_3();
@@ -28012,14 +28168,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:9790: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:9794:1: ( rule__Message__Group__0__Impl rule__Message__Group__1 )
+            // InternalRoom.g:9795:2: rule__Message__Group__0__Impl rule__Message__Group__1
             {
             pushFollow(FOLLOW_46);
             rule__Message__Group__0__Impl();
@@ -28050,29 +28206,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:9802: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:9806:1: ( ( ( rule__Message__PrivAssignment_0 )? ) )
+            // InternalRoom.g:9807:1: ( ( rule__Message__PrivAssignment_0 )? )
             {
-            // InternalRoom.g:9760:1: ( ( rule__Message__PrivAssignment_0 )? )
-            // InternalRoom.g:9761:1: ( rule__Message__PrivAssignment_0 )?
+            // InternalRoom.g:9807:1: ( ( rule__Message__PrivAssignment_0 )? )
+            // InternalRoom.g:9808: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:9809:1: ( rule__Message__PrivAssignment_0 )?
+            int alt106=2;
+            int LA106_0 = input.LA(1);
 
-            if ( (LA105_0==129) ) {
-                alt105=1;
+            if ( (LA106_0==129) ) {
+                alt106=1;
             }
-            switch (alt105) {
+            switch (alt106) {
                 case 1 :
-                    // InternalRoom.g:9762:2: rule__Message__PrivAssignment_0
+                    // InternalRoom.g:9809:2: rule__Message__PrivAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Message__PrivAssignment_0();
@@ -28108,14 +28264,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:9819: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:9823:1: ( rule__Message__Group__1__Impl rule__Message__Group__2 )
+            // InternalRoom.g:9824:2: rule__Message__Group__1__Impl rule__Message__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__Message__Group__1__Impl();
@@ -28146,17 +28302,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:9831: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:9835:1: ( ( 'Message' ) )
+            // InternalRoom.g:9836:1: ( 'Message' )
             {
-            // InternalRoom.g:9789:1: ( 'Message' )
-            // InternalRoom.g:9790:1: 'Message'
+            // InternalRoom.g:9836:1: ( 'Message' )
+            // InternalRoom.g:9837:1: 'Message'
             {
              before(grammarAccess.getMessageAccess().getMessageKeyword_1()); 
             match(input,25,FOLLOW_2); 
@@ -28183,14 +28339,14 @@ 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:9850: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:9854:1: ( rule__Message__Group__2__Impl rule__Message__Group__3 )
+            // InternalRoom.g:9855:2: rule__Message__Group__2__Impl rule__Message__Group__3
             {
             pushFollow(FOLLOW_33);
             rule__Message__Group__2__Impl();
@@ -28221,21 +28377,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:9862: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:9866:1: ( ( ( rule__Message__NameAssignment_2 ) ) )
+            // InternalRoom.g:9867:1: ( ( rule__Message__NameAssignment_2 ) )
             {
-            // InternalRoom.g:9820:1: ( ( rule__Message__NameAssignment_2 ) )
-            // InternalRoom.g:9821:1: ( rule__Message__NameAssignment_2 )
+            // InternalRoom.g:9867:1: ( ( rule__Message__NameAssignment_2 ) )
+            // InternalRoom.g:9868: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:9869:1: ( rule__Message__NameAssignment_2 )
+            // InternalRoom.g:9869:2: rule__Message__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Message__NameAssignment_2();
@@ -28268,14 +28424,14 @@ 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:9879: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:9883:1: ( rule__Message__Group__3__Impl rule__Message__Group__4 )
+            // InternalRoom.g:9884:2: rule__Message__Group__3__Impl rule__Message__Group__4
             {
             pushFollow(FOLLOW_34);
             rule__Message__Group__3__Impl();
@@ -28306,17 +28462,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__3__Impl"
-    // InternalRoom.g:9844:1: rule__Message__Group__3__Impl : ( '(' ) ;
+    // InternalRoom.g:9891:1: rule__Message__Group__3__Impl : ( '(' ) ;
     public final void rule__Message__Group__3__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9848:1: ( ( '(' ) )
-            // InternalRoom.g:9849:1: ( '(' )
+            // InternalRoom.g:9895:1: ( ( '(' ) )
+            // InternalRoom.g:9896:1: ( '(' )
             {
-            // InternalRoom.g:9849:1: ( '(' )
-            // InternalRoom.g:9850:1: '('
+            // InternalRoom.g:9896:1: ( '(' )
+            // InternalRoom.g:9897:1: '('
             {
              before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); 
             match(input,50,FOLLOW_2); 
@@ -28343,14 +28499,14 @@ 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:9910: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:9914:1: ( rule__Message__Group__4__Impl rule__Message__Group__5 )
+            // InternalRoom.g:9915:2: rule__Message__Group__4__Impl rule__Message__Group__5
             {
             pushFollow(FOLLOW_34);
             rule__Message__Group__4__Impl();
@@ -28381,29 +28537,29 @@ 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:9922:1: rule__Message__Group__4__Impl : ( ( rule__Message__DataAssignment_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:9926:1: ( ( ( rule__Message__DataAssignment_4 )? ) )
+            // InternalRoom.g:9927:1: ( ( rule__Message__DataAssignment_4 )? )
             {
-            // InternalRoom.g:9880:1: ( ( rule__Message__DataAssignment_4 )? )
-            // InternalRoom.g:9881:1: ( rule__Message__DataAssignment_4 )?
+            // InternalRoom.g:9927:1: ( ( rule__Message__DataAssignment_4 )? )
+            // InternalRoom.g:9928:1: ( rule__Message__DataAssignment_4 )?
             {
              before(grammarAccess.getMessageAccess().getDataAssignment_4()); 
-            // InternalRoom.g:9882:1: ( rule__Message__DataAssignment_4 )?
-            int alt106=2;
-            int LA106_0 = input.LA(1);
+            // InternalRoom.g:9929:1: ( rule__Message__DataAssignment_4 )?
+            int alt107=2;
+            int LA107_0 = input.LA(1);
 
-            if ( (LA106_0==RULE_ID) ) {
-                alt106=1;
+            if ( (LA107_0==RULE_ID) ) {
+                alt107=1;
             }
-            switch (alt106) {
+            switch (alt107) {
                 case 1 :
-                    // InternalRoom.g:9882:2: rule__Message__DataAssignment_4
+                    // InternalRoom.g:9929:2: rule__Message__DataAssignment_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__Message__DataAssignment_4();
@@ -28439,14 +28595,14 @@ 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:9939:1: rule__Message__Group__5 : rule__Message__Group__5__Impl rule__Message__Group__6 ;
     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:9943:1: ( rule__Message__Group__5__Impl rule__Message__Group__6 )
+            // InternalRoom.g:9944:2: rule__Message__Group__5__Impl rule__Message__Group__6
             {
             pushFollow(FOLLOW_47);
             rule__Message__Group__5__Impl();
@@ -28477,17 +28633,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__5__Impl"
-    // InternalRoom.g:9904:1: rule__Message__Group__5__Impl : ( ')' ) ;
+    // InternalRoom.g:9951:1: rule__Message__Group__5__Impl : ( ')' ) ;
     public final void rule__Message__Group__5__Impl() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:9908:1: ( ( ')' ) )
-            // InternalRoom.g:9909:1: ( ')' )
+            // InternalRoom.g:9955:1: ( ( ')' ) )
+            // InternalRoom.g:9956:1: ( ')' )
             {
-            // InternalRoom.g:9909:1: ( ')' )
-            // InternalRoom.g:9910:1: ')'
+            // InternalRoom.g:9956:1: ( ')' )
+            // InternalRoom.g:9957:1: ')'
             {
              before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); 
             match(input,51,FOLLOW_2); 
@@ -28514,14 +28670,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__6"
-    // InternalRoom.g:9923:1: rule__Message__Group__6 : rule__Message__Group__6__Impl rule__Message__Group__7 ;
+    // InternalRoom.g:9970:1: rule__Message__Group__6 : rule__Message__Group__6__Impl rule__Message__Group__7 ;
     public final void rule__Message__Group__6() 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:9974:1: ( rule__Message__Group__6__Impl rule__Message__Group__7 )
+            // InternalRoom.g:9975:2: rule__Message__Group__6__Impl rule__Message__Group__7
             {
             pushFollow(FOLLOW_47);
             rule__Message__Group__6__Impl();
@@ -28552,33 +28708,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__6__Impl"
-    // InternalRoom.g:9935:1: rule__Message__Group__6__Impl : ( ( rule__Message__AnnotationsAssignment_6 )* ) ;
+    // InternalRoom.g:9982:1: rule__Message__Group__6__Impl : ( ( rule__Message__AnnotationsAssignment_6 )* ) ;
     public final void rule__Message__Group__6__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:9986:1: ( ( ( rule__Message__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:9987:1: ( ( rule__Message__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:9940:1: ( ( rule__Message__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:9941:1: ( rule__Message__AnnotationsAssignment_6 )*
+            // InternalRoom.g:9987:1: ( ( rule__Message__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:9988:1: ( rule__Message__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getMessageAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:9942:1: ( rule__Message__AnnotationsAssignment_6 )*
-            loop107:
+            // InternalRoom.g:9989:1: ( rule__Message__AnnotationsAssignment_6 )*
+            loop108:
             do {
-                int alt107=2;
-                int LA107_0 = input.LA(1);
+                int alt108=2;
+                int LA108_0 = input.LA(1);
 
-                if ( (LA107_0==121) ) {
-                    alt107=1;
+                if ( (LA108_0==121) ) {
+                    alt108=1;
                 }
 
 
-                switch (alt107) {
+                switch (alt108) {
             	case 1 :
-            	    // InternalRoom.g:9942:2: rule__Message__AnnotationsAssignment_6
+            	    // InternalRoom.g:9989:2: rule__Message__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__Message__AnnotationsAssignment_6();
@@ -28590,7 +28746,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop107;
+            	    break loop108;
                 }
             } while (true);
 
@@ -28617,14 +28773,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__7"
-    // InternalRoom.g:9952:1: rule__Message__Group__7 : rule__Message__Group__7__Impl ;
+    // InternalRoom.g:9999:1: rule__Message__Group__7 : rule__Message__Group__7__Impl ;
     public final void rule__Message__Group__7() 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:10003:1: ( rule__Message__Group__7__Impl )
+            // InternalRoom.g:10004:2: rule__Message__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Message__Group__7__Impl();
@@ -28650,29 +28806,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__Group__7__Impl"
-    // InternalRoom.g:9963:1: rule__Message__Group__7__Impl : ( ( rule__Message__DocuAssignment_7 )? ) ;
+    // InternalRoom.g:10010:1: rule__Message__Group__7__Impl : ( ( rule__Message__DocuAssignment_7 )? ) ;
     public final void rule__Message__Group__7__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:10014:1: ( ( ( rule__Message__DocuAssignment_7 )? ) )
+            // InternalRoom.g:10015:1: ( ( rule__Message__DocuAssignment_7 )? )
             {
-            // InternalRoom.g:9968:1: ( ( rule__Message__DocuAssignment_7 )? )
-            // InternalRoom.g:9969:1: ( rule__Message__DocuAssignment_7 )?
+            // InternalRoom.g:10015:1: ( ( rule__Message__DocuAssignment_7 )? )
+            // InternalRoom.g:10016:1: ( rule__Message__DocuAssignment_7 )?
             {
              before(grammarAccess.getMessageAccess().getDocuAssignment_7()); 
-            // InternalRoom.g:9970:1: ( rule__Message__DocuAssignment_7 )?
-            int alt108=2;
-            int LA108_0 = input.LA(1);
+            // InternalRoom.g:10017:1: ( rule__Message__DocuAssignment_7 )?
+            int alt109=2;
+            int LA109_0 = input.LA(1);
 
-            if ( (LA108_0==62) ) {
-                alt108=1;
+            if ( (LA109_0==62) ) {
+                alt109=1;
             }
-            switch (alt108) {
+            switch (alt109) {
                 case 1 :
-                    // InternalRoom.g:9970:2: rule__Message__DocuAssignment_7
+                    // InternalRoom.g:10017:2: rule__Message__DocuAssignment_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__Message__DocuAssignment_7();
@@ -28708,14 +28864,14 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $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:10043: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:10047:1: ( rule__PortClass__Group__0__Impl rule__PortClass__Group__1 )
+            // InternalRoom.g:10048:2: rule__PortClass__Group__0__Impl rule__PortClass__Group__1
             {
             pushFollow(FOLLOW_40);
             rule__PortClass__Group__0__Impl();
@@ -28746,21 +28902,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__0__Impl"
-    // InternalRoom.g:10008:1: rule__PortClass__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:10055: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:10059:1: ( ( () ) )
+            // InternalRoom.g:10060:1: ( () )
             {
-            // InternalRoom.g:10013:1: ( () )
-            // InternalRoom.g:10014:1: ()
+            // InternalRoom.g:10060:1: ( () )
+            // InternalRoom.g:10061:1: ()
             {
              before(grammarAccess.getPortClassAccess().getPortClassAction_0()); 
-            // InternalRoom.g:10015:1: ()
-            // InternalRoom.g:10017:1: 
+            // InternalRoom.g:10062:1: ()
+            // InternalRoom.g:10064:1: 
             {
             }
 
@@ -28783,14 +28939,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:10074: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:10078:1: ( rule__PortClass__Group__1__Impl rule__PortClass__Group__2 )
+            // InternalRoom.g:10079:2: rule__PortClass__Group__1__Impl rule__PortClass__Group__2
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__1__Impl();
@@ -28821,17 +28977,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__1__Impl"
-    // InternalRoom.g:10039:1: rule__PortClass__Group__1__Impl : ( '{' ) ;
+    // InternalRoom.g:10086: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:10090:1: ( ( '{' ) )
+            // InternalRoom.g:10091:1: ( '{' )
             {
-            // InternalRoom.g:10044:1: ( '{' )
-            // InternalRoom.g:10045:1: '{'
+            // InternalRoom.g:10091:1: ( '{' )
+            // InternalRoom.g:10092:1: '{'
             {
              before(grammarAccess.getPortClassAccess().getLeftCurlyBracketKeyword_1()); 
             match(input,44,FOLLOW_2); 
@@ -28858,14 +29014,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:10105: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:10109:1: ( rule__PortClass__Group__2__Impl rule__PortClass__Group__3 )
+            // InternalRoom.g:10110:2: rule__PortClass__Group__2__Impl rule__PortClass__Group__3
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__2__Impl();
@@ -28896,29 +29052,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:10117: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:10121:1: ( ( ( rule__PortClass__Group_2__0 )? ) )
+            // InternalRoom.g:10122: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:10122:1: ( ( rule__PortClass__Group_2__0 )? )
+            // InternalRoom.g:10123: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:10124:1: ( rule__PortClass__Group_2__0 )?
+            int alt110=2;
+            int LA110_0 = input.LA(1);
 
-            if ( (LA109_0==72) ) {
-                alt109=1;
+            if ( (LA110_0==72) ) {
+                alt110=1;
             }
-            switch (alt109) {
+            switch (alt110) {
                 case 1 :
-                    // InternalRoom.g:10077:2: rule__PortClass__Group_2__0
+                    // InternalRoom.g:10124:2: rule__PortClass__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__PortClass__Group_2__0();
@@ -28954,14 +29110,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:10134: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:10138:1: ( rule__PortClass__Group__3__Impl rule__PortClass__Group__4 )
+            // InternalRoom.g:10139:2: rule__PortClass__Group__3__Impl rule__PortClass__Group__4
             {
             pushFollow(FOLLOW_48);
             rule__PortClass__Group__3__Impl();
@@ -28992,33 +29148,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:10146: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:10150:1: ( ( ( rule__PortClass__Alternatives_3 )* ) )
+            // InternalRoom.g:10151:1: ( ( rule__PortClass__Alternatives_3 )* )
             {
-            // InternalRoom.g:10104:1: ( ( rule__PortClass__Alternatives_3 )* )
-            // InternalRoom.g:10105:1: ( rule__PortClass__Alternatives_3 )*
+            // InternalRoom.g:10151:1: ( ( rule__PortClass__Alternatives_3 )* )
+            // InternalRoom.g:10152:1: ( rule__PortClass__Alternatives_3 )*
             {
              before(grammarAccess.getPortClassAccess().getAlternatives_3()); 
-            // InternalRoom.g:10106:1: ( rule__PortClass__Alternatives_3 )*
-            loop110:
+            // InternalRoom.g:10153:1: ( rule__PortClass__Alternatives_3 )*
+            loop111:
             do {
-                int alt110=2;
-                int LA110_0 = input.LA(1);
+                int alt111=2;
+                int LA111_0 = input.LA(1);
 
-                if ( (LA110_0==61||LA110_0==64||LA110_0==73) ) {
-                    alt110=1;
+                if ( (LA111_0==61||LA111_0==64||LA111_0==73) ) {
+                    alt111=1;
                 }
 
 
-                switch (alt110) {
+                switch (alt111) {
             	case 1 :
-            	    // InternalRoom.g:10106:2: rule__PortClass__Alternatives_3
+            	    // InternalRoom.g:10153:2: rule__PortClass__Alternatives_3
             	    {
             	    pushFollow(FOLLOW_49);
             	    rule__PortClass__Alternatives_3();
@@ -29030,7 +29186,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop110;
+            	    break loop111;
                 }
             } while (true);
 
@@ -29057,14 +29213,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:10163: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:10167:1: ( rule__PortClass__Group__4__Impl )
+            // InternalRoom.g:10168:2: rule__PortClass__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__Group__4__Impl();
@@ -29090,17 +29246,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__Group__4__Impl"
-    // InternalRoom.g:10127:1: rule__PortClass__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:10174: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:10178:1: ( ( '}' ) )
+            // InternalRoom.g:10179:1: ( '}' )
             {
-            // InternalRoom.g:10132:1: ( '}' )
-            // InternalRoom.g:10133:1: '}'
+            // InternalRoom.g:10179:1: ( '}' )
+            // InternalRoom.g:10180:1: '}'
             {
              before(grammarAccess.getPortClassAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -29127,14 +29283,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:10203: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:10207:1: ( rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1 )
+            // InternalRoom.g:10208:2: rule__PortClass__Group_2__0__Impl rule__PortClass__Group_2__1
             {
             pushFollow(FOLLOW_27);
             rule__PortClass__Group_2__0__Impl();
@@ -29165,17 +29321,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:10215: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:10219:1: ( ( 'usercode' ) )
+            // InternalRoom.g:10220:1: ( 'usercode' )
             {
-            // InternalRoom.g:10173:1: ( 'usercode' )
-            // InternalRoom.g:10174:1: 'usercode'
+            // InternalRoom.g:10220:1: ( 'usercode' )
+            // InternalRoom.g:10221:1: 'usercode'
             {
              before(grammarAccess.getPortClassAccess().getUsercodeKeyword_2_0()); 
             match(input,72,FOLLOW_2); 
@@ -29202,14 +29358,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:10234: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:10238:1: ( rule__PortClass__Group_2__1__Impl )
+            // InternalRoom.g:10239:2: rule__PortClass__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__Group_2__1__Impl();
@@ -29235,21 +29391,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:10245: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:10249:1: ( ( ( rule__PortClass__UserCodeAssignment_2_1 ) ) )
+            // InternalRoom.g:10250: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:10250:1: ( ( rule__PortClass__UserCodeAssignment_2_1 ) )
+            // InternalRoom.g:10251: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:10252:1: ( rule__PortClass__UserCodeAssignment_2_1 )
+            // InternalRoom.g:10252:2: rule__PortClass__UserCodeAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__PortClass__UserCodeAssignment_2_1();
@@ -29282,14 +29438,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:10266: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:10270:1: ( rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1 )
+            // InternalRoom.g:10271:2: rule__InMessageHandler__Group__0__Impl rule__InMessageHandler__Group__1
             {
             pushFollow(FOLLOW_50);
             rule__InMessageHandler__Group__0__Impl();
@@ -29320,17 +29476,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:10278: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:10282:1: ( ( 'handle' ) )
+            // InternalRoom.g:10283:1: ( 'handle' )
             {
-            // InternalRoom.g:10236:1: ( 'handle' )
-            // InternalRoom.g:10237:1: 'handle'
+            // InternalRoom.g:10283:1: ( 'handle' )
+            // InternalRoom.g:10284:1: 'handle'
             {
              before(grammarAccess.getInMessageHandlerAccess().getHandleKeyword_0()); 
             match(input,73,FOLLOW_2); 
@@ -29357,14 +29513,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:10297: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:10301:1: ( rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2 )
+            // InternalRoom.g:10302:2: rule__InMessageHandler__Group__1__Impl rule__InMessageHandler__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__InMessageHandler__Group__1__Impl();
@@ -29395,17 +29551,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:10309: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:10313:1: ( ( 'incoming' ) )
+            // InternalRoom.g:10314:1: ( 'incoming' )
             {
-            // InternalRoom.g:10267:1: ( 'incoming' )
-            // InternalRoom.g:10268:1: 'incoming'
+            // InternalRoom.g:10314:1: ( 'incoming' )
+            // InternalRoom.g:10315:1: 'incoming'
             {
              before(grammarAccess.getInMessageHandlerAccess().getIncomingKeyword_1()); 
             match(input,66,FOLLOW_2); 
@@ -29432,14 +29588,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:10328: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:10332:1: ( rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3 )
+            // InternalRoom.g:10333:2: rule__InMessageHandler__Group__2__Impl rule__InMessageHandler__Group__3
             {
             pushFollow(FOLLOW_27);
             rule__InMessageHandler__Group__2__Impl();
@@ -29470,21 +29626,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:10340: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:10344:1: ( ( ( rule__InMessageHandler__MsgAssignment_2 ) ) )
+            // InternalRoom.g:10345:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:10298:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
-            // InternalRoom.g:10299:1: ( rule__InMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10345:1: ( ( rule__InMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10346: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:10347:1: ( rule__InMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10347:2: rule__InMessageHandler__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__MsgAssignment_2();
@@ -29517,14 +29673,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:10357: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:10361:1: ( rule__InMessageHandler__Group__3__Impl )
+            // InternalRoom.g:10362:2: rule__InMessageHandler__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__Group__3__Impl();
@@ -29550,21 +29706,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:10368: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:10372:1: ( ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) ) )
+            // InternalRoom.g:10373:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
             {
-            // InternalRoom.g:10326:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
-            // InternalRoom.g:10327:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10373:1: ( ( rule__InMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10374: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:10375:1: ( rule__InMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10375:2: rule__InMessageHandler__DetailCodeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__InMessageHandler__DetailCodeAssignment_3();
@@ -29597,14 +29753,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:10393: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:10397:1: ( rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1 )
+            // InternalRoom.g:10398:2: rule__OutMessageHandler__Group__0__Impl rule__OutMessageHandler__Group__1
             {
             pushFollow(FOLLOW_51);
             rule__OutMessageHandler__Group__0__Impl();
@@ -29635,17 +29791,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:10405: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:10409:1: ( ( 'handle' ) )
+            // InternalRoom.g:10410:1: ( 'handle' )
             {
-            // InternalRoom.g:10363:1: ( 'handle' )
-            // InternalRoom.g:10364:1: 'handle'
+            // InternalRoom.g:10410:1: ( 'handle' )
+            // InternalRoom.g:10411:1: 'handle'
             {
              before(grammarAccess.getOutMessageHandlerAccess().getHandleKeyword_0()); 
             match(input,73,FOLLOW_2); 
@@ -29672,14 +29828,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:10424: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:10428:1: ( rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2 )
+            // InternalRoom.g:10429:2: rule__OutMessageHandler__Group__1__Impl rule__OutMessageHandler__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__OutMessageHandler__Group__1__Impl();
@@ -29710,17 +29866,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:10436: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:10440:1: ( ( 'outgoing' ) )
+            // InternalRoom.g:10441:1: ( 'outgoing' )
             {
-            // InternalRoom.g:10394:1: ( 'outgoing' )
-            // InternalRoom.g:10395:1: 'outgoing'
+            // InternalRoom.g:10441:1: ( 'outgoing' )
+            // InternalRoom.g:10442:1: 'outgoing'
             {
              before(grammarAccess.getOutMessageHandlerAccess().getOutgoingKeyword_1()); 
             match(input,67,FOLLOW_2); 
@@ -29747,14 +29903,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:10455: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:10459:1: ( rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3 )
+            // InternalRoom.g:10460:2: rule__OutMessageHandler__Group__2__Impl rule__OutMessageHandler__Group__3
             {
             pushFollow(FOLLOW_27);
             rule__OutMessageHandler__Group__2__Impl();
@@ -29785,21 +29941,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:10467: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:10471:1: ( ( ( rule__OutMessageHandler__MsgAssignment_2 ) ) )
+            // InternalRoom.g:10472:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:10425:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
-            // InternalRoom.g:10426:1: ( rule__OutMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10472:1: ( ( rule__OutMessageHandler__MsgAssignment_2 ) )
+            // InternalRoom.g:10473: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:10474:1: ( rule__OutMessageHandler__MsgAssignment_2 )
+            // InternalRoom.g:10474:2: rule__OutMessageHandler__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__MsgAssignment_2();
@@ -29832,14 +29988,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:10484: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:10488:1: ( rule__OutMessageHandler__Group__3__Impl )
+            // InternalRoom.g:10489:2: rule__OutMessageHandler__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__Group__3__Impl();
@@ -29865,21 +30021,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:10495: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:10499:1: ( ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) ) )
+            // InternalRoom.g:10500:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
             {
-            // InternalRoom.g:10453:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
-            // InternalRoom.g:10454:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10500:1: ( ( rule__OutMessageHandler__DetailCodeAssignment_3 ) )
+            // InternalRoom.g:10501: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:10502:1: ( rule__OutMessageHandler__DetailCodeAssignment_3 )
+            // InternalRoom.g:10502:2: rule__OutMessageHandler__DetailCodeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__OutMessageHandler__DetailCodeAssignment_3();
@@ -29912,14 +30068,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:10520: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:10524:1: ( rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1 )
+            // InternalRoom.g:10525:2: rule__ActorClass__Group__0__Impl rule__ActorClass__Group__1
             {
             pushFollow(FOLLOW_52);
             rule__ActorClass__Group__0__Impl();
@@ -29950,21 +30106,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:10532: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:10536:1: ( ( ( rule__ActorClass__UnorderedGroup_0 ) ) )
+            // InternalRoom.g:10537:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
             {
-            // InternalRoom.g:10490:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
-            // InternalRoom.g:10491:1: ( rule__ActorClass__UnorderedGroup_0 )
+            // InternalRoom.g:10537:1: ( ( rule__ActorClass__UnorderedGroup_0 ) )
+            // InternalRoom.g:10538: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:10539:1: ( rule__ActorClass__UnorderedGroup_0 )
+            // InternalRoom.g:10539:2: rule__ActorClass__UnorderedGroup_0
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UnorderedGroup_0();
@@ -29997,14 +30153,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:10549: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:10553:1: ( rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2 )
+            // InternalRoom.g:10554:2: rule__ActorClass__Group__1__Impl rule__ActorClass__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ActorClass__Group__1__Impl();
@@ -30035,17 +30191,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:10561: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:10565:1: ( ( 'ActorClass' ) )
+            // InternalRoom.g:10566:1: ( 'ActorClass' )
             {
-            // InternalRoom.g:10519:1: ( 'ActorClass' )
-            // InternalRoom.g:10520:1: 'ActorClass'
+            // InternalRoom.g:10566:1: ( 'ActorClass' )
+            // InternalRoom.g:10567:1: 'ActorClass'
             {
              before(grammarAccess.getActorClassAccess().getActorClassKeyword_1()); 
             match(input,18,FOLLOW_2); 
@@ -30072,14 +30228,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:10580: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:10584:1: ( rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3 )
+            // InternalRoom.g:10585:2: rule__ActorClass__Group__2__Impl rule__ActorClass__Group__3
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__2__Impl();
@@ -30110,21 +30266,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:10592: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:10596:1: ( ( ( rule__ActorClass__NameAssignment_2 ) ) )
+            // InternalRoom.g:10597:1: ( ( rule__ActorClass__NameAssignment_2 ) )
             {
-            // InternalRoom.g:10550:1: ( ( rule__ActorClass__NameAssignment_2 ) )
-            // InternalRoom.g:10551:1: ( rule__ActorClass__NameAssignment_2 )
+            // InternalRoom.g:10597:1: ( ( rule__ActorClass__NameAssignment_2 ) )
+            // InternalRoom.g:10598: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:10599:1: ( rule__ActorClass__NameAssignment_2 )
+            // InternalRoom.g:10599:2: rule__ActorClass__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__NameAssignment_2();
@@ -30157,14 +30313,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:10609: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:10613:1: ( rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4 )
+            // InternalRoom.g:10614:2: rule__ActorClass__Group__3__Impl rule__ActorClass__Group__4
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__3__Impl();
@@ -30195,29 +30351,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:10621: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:10625:1: ( ( ( rule__ActorClass__DocuAssignment_3 )? ) )
+            // InternalRoom.g:10626:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
             {
-            // InternalRoom.g:10579:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
-            // InternalRoom.g:10580:1: ( rule__ActorClass__DocuAssignment_3 )?
+            // InternalRoom.g:10626:1: ( ( rule__ActorClass__DocuAssignment_3 )? )
+            // InternalRoom.g:10627: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:10628:1: ( rule__ActorClass__DocuAssignment_3 )?
+            int alt112=2;
+            int LA112_0 = input.LA(1);
 
-            if ( (LA111_0==62) ) {
-                alt111=1;
+            if ( (LA112_0==62) ) {
+                alt112=1;
             }
-            switch (alt111) {
+            switch (alt112) {
                 case 1 :
-                    // InternalRoom.g:10581:2: rule__ActorClass__DocuAssignment_3
+                    // InternalRoom.g:10628:2: rule__ActorClass__DocuAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__DocuAssignment_3();
@@ -30253,14 +30409,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:10638: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:10642:1: ( rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5 )
+            // InternalRoom.g:10643:2: rule__ActorClass__Group__4__Impl rule__ActorClass__Group__5
             {
             pushFollow(FOLLOW_23);
             rule__ActorClass__Group__4__Impl();
@@ -30291,29 +30447,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:10650: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:10654:1: ( ( ( rule__ActorClass__Group_4__0 )? ) )
+            // InternalRoom.g:10655: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:10655:1: ( ( rule__ActorClass__Group_4__0 )? )
+            // InternalRoom.g:10656: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:10657:1: ( rule__ActorClass__Group_4__0 )?
+            int alt113=2;
+            int LA113_0 = input.LA(1);
 
-            if ( (LA112_0==57) ) {
-                alt112=1;
+            if ( (LA113_0==57) ) {
+                alt113=1;
             }
-            switch (alt112) {
+            switch (alt113) {
                 case 1 :
-                    // InternalRoom.g:10610:2: rule__ActorClass__Group_4__0
+                    // InternalRoom.g:10657:2: rule__ActorClass__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_4__0();
@@ -30349,14 +30505,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:10667: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:10671:1: ( rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6 )
+            // InternalRoom.g:10672:2: rule__ActorClass__Group__5__Impl rule__ActorClass__Group__6
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__5__Impl();
@@ -30387,17 +30543,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__5__Impl"
-    // InternalRoom.g:10632:1: rule__ActorClass__Group__5__Impl : ( '{' ) ;
+    // InternalRoom.g:10679: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:10683:1: ( ( '{' ) )
+            // InternalRoom.g:10684:1: ( '{' )
             {
-            // InternalRoom.g:10637:1: ( '{' )
-            // InternalRoom.g:10638:1: '{'
+            // InternalRoom.g:10684:1: ( '{' )
+            // InternalRoom.g:10685:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_5()); 
             match(input,44,FOLLOW_2); 
@@ -30424,14 +30580,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:10698: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:10702:1: ( rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7 )
+            // InternalRoom.g:10703:2: rule__ActorClass__Group__6__Impl rule__ActorClass__Group__7
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__6__Impl();
@@ -30462,33 +30618,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:10710: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:10714:1: ( ( ( rule__ActorClass__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:10715:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:10668:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:10669:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
+            // InternalRoom.g:10715:1: ( ( rule__ActorClass__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:10716:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getActorClassAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:10670:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
-            loop113:
+            // InternalRoom.g:10717:1: ( rule__ActorClass__AnnotationsAssignment_6 )*
+            loop114:
             do {
-                int alt113=2;
-                int LA113_0 = input.LA(1);
+                int alt114=2;
+                int LA114_0 = input.LA(1);
 
-                if ( (LA113_0==121) ) {
-                    alt113=1;
+                if ( (LA114_0==121) ) {
+                    alt114=1;
                 }
 
 
-                switch (alt113) {
+                switch (alt114) {
             	case 1 :
-            	    // InternalRoom.g:10670:2: rule__ActorClass__AnnotationsAssignment_6
+            	    // InternalRoom.g:10717:2: rule__ActorClass__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ActorClass__AnnotationsAssignment_6();
@@ -30500,7 +30656,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop113;
+            	    break loop114;
                 }
             } while (true);
 
@@ -30527,14 +30683,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:10727: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:10731:1: ( rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8 )
+            // InternalRoom.g:10732:2: rule__ActorClass__Group__7__Impl rule__ActorClass__Group__8
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__7__Impl();
@@ -30565,29 +30721,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:10739: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:10743:1: ( ( ( rule__ActorClass__Group_7__0 )? ) )
+            // InternalRoom.g:10744: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:10744:1: ( ( rule__ActorClass__Group_7__0 )? )
+            // InternalRoom.g:10745: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:10746:1: ( rule__ActorClass__Group_7__0 )?
+            int alt115=2;
+            int LA115_0 = input.LA(1);
 
-            if ( (LA114_0==74) ) {
-                alt114=1;
+            if ( (LA115_0==74) ) {
+                alt115=1;
             }
-            switch (alt114) {
+            switch (alt115) {
                 case 1 :
-                    // InternalRoom.g:10699:2: rule__ActorClass__Group_7__0
+                    // InternalRoom.g:10746:2: rule__ActorClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_7__0();
@@ -30623,14 +30779,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:10756: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:10760:1: ( rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9 )
+            // InternalRoom.g:10761:2: rule__ActorClass__Group__8__Impl rule__ActorClass__Group__9
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__8__Impl();
@@ -30661,29 +30817,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:10768: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:10772:1: ( ( ( rule__ActorClass__Group_8__0 )? ) )
+            // InternalRoom.g:10773: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:10773:1: ( ( rule__ActorClass__Group_8__0 )? )
+            // InternalRoom.g:10774: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:10775:1: ( rule__ActorClass__Group_8__0 )?
+            int alt116=2;
+            int LA116_0 = input.LA(1);
 
-            if ( (LA115_0==75) ) {
-                alt115=1;
+            if ( (LA116_0==75) ) {
+                alt116=1;
             }
-            switch (alt115) {
+            switch (alt116) {
                 case 1 :
-                    // InternalRoom.g:10728:2: rule__ActorClass__Group_8__0
+                    // InternalRoom.g:10775:2: rule__ActorClass__Group_8__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8__0();
@@ -30719,14 +30875,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:10785: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:10789:1: ( rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10 )
+            // InternalRoom.g:10790:2: rule__ActorClass__Group__9__Impl rule__ActorClass__Group__10
             {
             pushFollow(FOLLOW_53);
             rule__ActorClass__Group__9__Impl();
@@ -30757,29 +30913,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:10797: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:10801:1: ( ( ( rule__ActorClass__Group_9__0 )? ) )
+            // InternalRoom.g:10802: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:10802:1: ( ( rule__ActorClass__Group_9__0 )? )
+            // InternalRoom.g:10803: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:10804:1: ( rule__ActorClass__Group_9__0 )?
+            int alt117=2;
+            int LA117_0 = input.LA(1);
 
-            if ( (LA116_0==76) ) {
-                alt116=1;
+            if ( (LA117_0==76) ) {
+                alt117=1;
             }
-            switch (alt116) {
+            switch (alt117) {
                 case 1 :
-                    // InternalRoom.g:10757:2: rule__ActorClass__Group_9__0
+                    // InternalRoom.g:10804:2: rule__ActorClass__Group_9__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_9__0();
@@ -30815,14 +30971,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:10814: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:10818:1: ( rule__ActorClass__Group__10__Impl )
+            // InternalRoom.g:10819:2: rule__ActorClass__Group__10__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group__10__Impl();
@@ -30848,17 +31004,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__Group__10__Impl"
-    // InternalRoom.g:10778:1: rule__ActorClass__Group__10__Impl : ( '}' ) ;
+    // InternalRoom.g:10825: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:10829:1: ( ( '}' ) )
+            // InternalRoom.g:10830:1: ( '}' )
             {
-            // InternalRoom.g:10783:1: ( '}' )
-            // InternalRoom.g:10784:1: '}'
+            // InternalRoom.g:10830:1: ( '}' )
+            // InternalRoom.g:10831:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_10()); 
             match(input,45,FOLLOW_2); 
@@ -30885,14 +31041,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:10866: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:10870:1: ( rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1 )
+            // InternalRoom.g:10871:2: rule__ActorClass__Group_4__0__Impl rule__ActorClass__Group_4__1
             {
             pushFollow(FOLLOW_3);
             rule__ActorClass__Group_4__0__Impl();
@@ -30923,17 +31079,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:10878: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:10882:1: ( ( 'extends' ) )
+            // InternalRoom.g:10883:1: ( 'extends' )
             {
-            // InternalRoom.g:10836:1: ( 'extends' )
-            // InternalRoom.g:10837:1: 'extends'
+            // InternalRoom.g:10883:1: ( 'extends' )
+            // InternalRoom.g:10884:1: 'extends'
             {
              before(grammarAccess.getActorClassAccess().getExtendsKeyword_4_0()); 
             match(input,57,FOLLOW_2); 
@@ -30960,14 +31116,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:10897: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:10901:1: ( rule__ActorClass__Group_4__1__Impl )
+            // InternalRoom.g:10902:2: rule__ActorClass__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_4__1__Impl();
@@ -30993,21 +31149,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:10908: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:10912:1: ( ( ( rule__ActorClass__BaseAssignment_4_1 ) ) )
+            // InternalRoom.g:10913: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:10913:1: ( ( rule__ActorClass__BaseAssignment_4_1 ) )
+            // InternalRoom.g:10914: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:10915:1: ( rule__ActorClass__BaseAssignment_4_1 )
+            // InternalRoom.g:10915:2: rule__ActorClass__BaseAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__BaseAssignment_4_1();
@@ -31040,14 +31196,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:10929: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:10933:1: ( rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1 )
+            // InternalRoom.g:10934:2: rule__ActorClass__Group_7__0__Impl rule__ActorClass__Group_7__1
             {
             pushFollow(FOLLOW_40);
             rule__ActorClass__Group_7__0__Impl();
@@ -31078,17 +31234,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:10941: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:10945:1: ( ( 'Interface' ) )
+            // InternalRoom.g:10946:1: ( 'Interface' )
             {
-            // InternalRoom.g:10899:1: ( 'Interface' )
-            // InternalRoom.g:10900:1: 'Interface'
+            // InternalRoom.g:10946:1: ( 'Interface' )
+            // InternalRoom.g:10947:1: 'Interface'
             {
              before(grammarAccess.getActorClassAccess().getInterfaceKeyword_7_0()); 
             match(input,74,FOLLOW_2); 
@@ -31115,14 +31271,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:10960: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:10964:1: ( rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2 )
+            // InternalRoom.g:10965:2: rule__ActorClass__Group_7__1__Impl rule__ActorClass__Group_7__2
             {
             pushFollow(FOLLOW_54);
             rule__ActorClass__Group_7__1__Impl();
@@ -31153,17 +31309,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:10972: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:10976:1: ( ( '{' ) )
+            // InternalRoom.g:10977:1: ( '{' )
             {
-            // InternalRoom.g:10930:1: ( '{' )
-            // InternalRoom.g:10931:1: '{'
+            // InternalRoom.g:10977:1: ( '{' )
+            // InternalRoom.g:10978:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_7_1()); 
             match(input,44,FOLLOW_2); 
@@ -31190,14 +31346,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:10991: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:10995:1: ( rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3 )
+            // InternalRoom.g:10996:2: rule__ActorClass__Group_7__2__Impl rule__ActorClass__Group_7__3
             {
             pushFollow(FOLLOW_54);
             rule__ActorClass__Group_7__2__Impl();
@@ -31228,33 +31384,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:11003: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:11007:1: ( ( ( rule__ActorClass__Alternatives_7_2 )* ) )
+            // InternalRoom.g:11008: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:11008:1: ( ( rule__ActorClass__Alternatives_7_2 )* )
+            // InternalRoom.g:11009:1: ( rule__ActorClass__Alternatives_7_2 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_7_2()); 
-            // InternalRoom.g:10963:1: ( rule__ActorClass__Alternatives_7_2 )*
-            loop117:
+            // InternalRoom.g:11010:1: ( rule__ActorClass__Alternatives_7_2 )*
+            loop118:
             do {
-                int alt117=2;
-                int LA117_0 = input.LA(1);
+                int alt118=2;
+                int LA118_0 = input.LA(1);
 
-                if ( (LA117_0==24||LA117_0==70||LA117_0==79) ) {
-                    alt117=1;
+                if ( (LA118_0==24||LA118_0==70||LA118_0==79) ) {
+                    alt118=1;
                 }
 
 
-                switch (alt117) {
+                switch (alt118) {
             	case 1 :
-            	    // InternalRoom.g:10963:2: rule__ActorClass__Alternatives_7_2
+            	    // InternalRoom.g:11010:2: rule__ActorClass__Alternatives_7_2
             	    {
             	    pushFollow(FOLLOW_55);
             	    rule__ActorClass__Alternatives_7_2();
@@ -31266,7 +31422,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop117;
+            	    break loop118;
                 }
             } while (true);
 
@@ -31293,14 +31449,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:11020: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:11024:1: ( rule__ActorClass__Group_7__3__Impl )
+            // InternalRoom.g:11025:2: rule__ActorClass__Group_7__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_7__3__Impl();
@@ -31326,17 +31482,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:11031: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:11035:1: ( ( '}' ) )
+            // InternalRoom.g:11036:1: ( '}' )
             {
-            // InternalRoom.g:10989:1: ( '}' )
-            // InternalRoom.g:10990:1: '}'
+            // InternalRoom.g:11036:1: ( '}' )
+            // InternalRoom.g:11037:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_7_3()); 
             match(input,45,FOLLOW_2); 
@@ -31363,14 +31519,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:11058: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:11062:1: ( rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1 )
+            // InternalRoom.g:11063:2: rule__ActorClass__Group_8__0__Impl rule__ActorClass__Group_8__1
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_8__0__Impl();
@@ -31401,17 +31557,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:11070: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:11074:1: ( ( 'Structure' ) )
+            // InternalRoom.g:11075:1: ( 'Structure' )
             {
-            // InternalRoom.g:11028:1: ( 'Structure' )
-            // InternalRoom.g:11029:1: 'Structure'
+            // InternalRoom.g:11075:1: ( 'Structure' )
+            // InternalRoom.g:11076:1: 'Structure'
             {
              before(grammarAccess.getActorClassAccess().getStructureKeyword_8_0()); 
             match(input,75,FOLLOW_2); 
@@ -31438,14 +31594,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:11089: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:11093:1: ( rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2 )
+            // InternalRoom.g:11094:2: rule__ActorClass__Group_8__1__Impl rule__ActorClass__Group_8__2
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_8__1__Impl();
@@ -31476,29 +31632,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:11101: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:11105:1: ( ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? ) )
+            // InternalRoom.g:11106: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:11106:1: ( ( rule__ActorClass__StructureDocuAssignment_8_1 )? )
+            // InternalRoom.g:11107: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:11108:1: ( rule__ActorClass__StructureDocuAssignment_8_1 )?
+            int alt119=2;
+            int LA119_0 = input.LA(1);
 
-            if ( (LA118_0==62) ) {
-                alt118=1;
+            if ( (LA119_0==62) ) {
+                alt119=1;
             }
-            switch (alt118) {
+            switch (alt119) {
                 case 1 :
-                    // InternalRoom.g:11061:2: rule__ActorClass__StructureDocuAssignment_8_1
+                    // InternalRoom.g:11108:2: rule__ActorClass__StructureDocuAssignment_8_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StructureDocuAssignment_8_1();
@@ -31534,14 +31690,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:11118: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:11122:1: ( rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3 )
+            // InternalRoom.g:11123:2: rule__ActorClass__Group_8__2__Impl rule__ActorClass__Group_8__3
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__2__Impl();
@@ -31572,17 +31728,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:11130: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:11134:1: ( ( '{' ) )
+            // InternalRoom.g:11135:1: ( '{' )
             {
-            // InternalRoom.g:11088:1: ( '{' )
-            // InternalRoom.g:11089:1: '{'
+            // InternalRoom.g:11135:1: ( '{' )
+            // InternalRoom.g:11136:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_8_2()); 
             match(input,44,FOLLOW_2); 
@@ -31609,14 +31765,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:11149: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:11153:1: ( rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4 )
+            // InternalRoom.g:11154:2: rule__ActorClass__Group_8__3__Impl rule__ActorClass__Group_8__4
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__3__Impl();
@@ -31647,29 +31803,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:11161: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:11165:1: ( ( ( rule__ActorClass__Group_8_3__0 )? ) )
+            // InternalRoom.g:11166: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:11166:1: ( ( rule__ActorClass__Group_8_3__0 )? )
+            // InternalRoom.g:11167: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:11168:1: ( rule__ActorClass__Group_8_3__0 )?
+            int alt120=2;
+            int LA120_0 = input.LA(1);
 
-            if ( (LA119_0==58) ) {
-                alt119=1;
+            if ( (LA120_0==58) ) {
+                alt120=1;
             }
-            switch (alt119) {
+            switch (alt120) {
                 case 1 :
-                    // InternalRoom.g:11121:2: rule__ActorClass__Group_8_3__0
+                    // InternalRoom.g:11168:2: rule__ActorClass__Group_8_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_3__0();
@@ -31705,14 +31861,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:11178: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:11182:1: ( rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5 )
+            // InternalRoom.g:11183:2: rule__ActorClass__Group_8__4__Impl rule__ActorClass__Group_8__5
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__4__Impl();
@@ -31743,29 +31899,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:11190: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:11194:1: ( ( ( rule__ActorClass__Group_8_4__0 )? ) )
+            // InternalRoom.g:11195: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:11195:1: ( ( rule__ActorClass__Group_8_4__0 )? )
+            // InternalRoom.g:11196: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:11197:1: ( rule__ActorClass__Group_8_4__0 )?
+            int alt121=2;
+            int LA121_0 = input.LA(1);
 
-            if ( (LA120_0==59) ) {
-                alt120=1;
+            if ( (LA121_0==59) ) {
+                alt121=1;
             }
-            switch (alt120) {
+            switch (alt121) {
                 case 1 :
-                    // InternalRoom.g:11150:2: rule__ActorClass__Group_8_4__0
+                    // InternalRoom.g:11197:2: rule__ActorClass__Group_8_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_4__0();
@@ -31801,14 +31957,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:11207: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:11211:1: ( rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6 )
+            // InternalRoom.g:11212:2: rule__ActorClass__Group_8__5__Impl rule__ActorClass__Group_8__6
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__5__Impl();
@@ -31839,29 +31995,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:11219: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:11223:1: ( ( ( rule__ActorClass__Group_8_5__0 )? ) )
+            // InternalRoom.g:11224: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:11224:1: ( ( rule__ActorClass__Group_8_5__0 )? )
+            // InternalRoom.g:11225: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:11226:1: ( rule__ActorClass__Group_8_5__0 )?
+            int alt122=2;
+            int LA122_0 = input.LA(1);
 
-            if ( (LA121_0==60) ) {
-                alt121=1;
+            if ( (LA122_0==60) ) {
+                alt122=1;
             }
-            switch (alt121) {
+            switch (alt122) {
                 case 1 :
-                    // InternalRoom.g:11179:2: rule__ActorClass__Group_8_5__0
+                    // InternalRoom.g:11226:2: rule__ActorClass__Group_8_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__Group_8_5__0();
@@ -31897,14 +32053,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:11236: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:11240:1: ( rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7 )
+            // InternalRoom.g:11241:2: rule__ActorClass__Group_8__6__Impl rule__ActorClass__Group_8__7
             {
             pushFollow(FOLLOW_56);
             rule__ActorClass__Group_8__6__Impl();
@@ -31935,33 +32091,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:11248: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:11252:1: ( ( ( rule__ActorClass__Alternatives_8_6 )* ) )
+            // InternalRoom.g:11253: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:11253:1: ( ( rule__ActorClass__Alternatives_8_6 )* )
+            // InternalRoom.g:11254:1: ( rule__ActorClass__Alternatives_8_6 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_8_6()); 
-            // InternalRoom.g:11208:1: ( rule__ActorClass__Alternatives_8_6 )*
-            loop122:
+            // InternalRoom.g:11255:1: ( rule__ActorClass__Alternatives_8_6 )*
+            loop123:
             do {
-                int alt122=2;
-                int LA122_0 = input.LA(1);
+                int alt123=2;
+                int LA123_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 ( (LA123_0==24||(LA123_0>=36 && LA123_0<=37)||LA123_0==61||LA123_0==70||(LA123_0>=77 && LA123_0<=78)||LA123_0==80||LA123_0==85||LA123_0==89||LA123_0==93) ) {
+                    alt123=1;
                 }
 
 
-                switch (alt122) {
+                switch (alt123) {
             	case 1 :
-            	    // InternalRoom.g:11208:2: rule__ActorClass__Alternatives_8_6
+            	    // InternalRoom.g:11255:2: rule__ActorClass__Alternatives_8_6
             	    {
             	    pushFollow(FOLLOW_57);
             	    rule__ActorClass__Alternatives_8_6();
@@ -31973,7 +32129,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop122;
+            	    break loop123;
                 }
             } while (true);
 
@@ -32000,14 +32156,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:11265: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:11269:1: ( rule__ActorClass__Group_8__7__Impl )
+            // InternalRoom.g:11270:2: rule__ActorClass__Group_8__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8__7__Impl();
@@ -32033,17 +32189,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:11276: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:11280:1: ( ( '}' ) )
+            // InternalRoom.g:11281:1: ( '}' )
             {
-            // InternalRoom.g:11234:1: ( '}' )
-            // InternalRoom.g:11235:1: '}'
+            // InternalRoom.g:11281:1: ( '}' )
+            // InternalRoom.g:11282:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_8_7()); 
             match(input,45,FOLLOW_2); 
@@ -32070,14 +32226,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:11311: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:11315:1: ( rule__ActorClass__Group_8_3__0__Impl rule__ActorClass__Group_8_3__1 )
+            // InternalRoom.g:11316: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 +32264,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:11323: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:11327:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:11328:1: ( 'usercode1' )
             {
-            // InternalRoom.g:11281:1: ( 'usercode1' )
-            // InternalRoom.g:11282:1: 'usercode1'
+            // InternalRoom.g:11328:1: ( 'usercode1' )
+            // InternalRoom.g:11329:1: 'usercode1'
             {
              before(grammarAccess.getActorClassAccess().getUsercode1Keyword_8_3_0()); 
             match(input,58,FOLLOW_2); 
@@ -32145,14 +32301,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:11342: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:11346:1: ( rule__ActorClass__Group_8_3__1__Impl )
+            // InternalRoom.g:11347:2: rule__ActorClass__Group_8_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_3__1__Impl();
@@ -32178,21 +32334,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:11353: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:11357:1: ( ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) ) )
+            // InternalRoom.g:11358: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:11358:1: ( ( rule__ActorClass__UserCode1Assignment_8_3_1 ) )
+            // InternalRoom.g:11359: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:11360:1: ( rule__ActorClass__UserCode1Assignment_8_3_1 )
+            // InternalRoom.g:11360:2: rule__ActorClass__UserCode1Assignment_8_3_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode1Assignment_8_3_1();
@@ -32225,14 +32381,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:11374: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:11378:1: ( rule__ActorClass__Group_8_4__0__Impl rule__ActorClass__Group_8_4__1 )
+            // InternalRoom.g:11379: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 +32419,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:11386: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:11390:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:11391:1: ( 'usercode2' )
             {
-            // InternalRoom.g:11344:1: ( 'usercode2' )
-            // InternalRoom.g:11345:1: 'usercode2'
+            // InternalRoom.g:11391:1: ( 'usercode2' )
+            // InternalRoom.g:11392:1: 'usercode2'
             {
              before(grammarAccess.getActorClassAccess().getUsercode2Keyword_8_4_0()); 
             match(input,59,FOLLOW_2); 
@@ -32300,14 +32456,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:11405: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:11409:1: ( rule__ActorClass__Group_8_4__1__Impl )
+            // InternalRoom.g:11410:2: rule__ActorClass__Group_8_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_4__1__Impl();
@@ -32333,21 +32489,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:11416: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:11420:1: ( ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) ) )
+            // InternalRoom.g:11421: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:11421:1: ( ( rule__ActorClass__UserCode2Assignment_8_4_1 ) )
+            // InternalRoom.g:11422: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:11423:1: ( rule__ActorClass__UserCode2Assignment_8_4_1 )
+            // InternalRoom.g:11423:2: rule__ActorClass__UserCode2Assignment_8_4_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode2Assignment_8_4_1();
@@ -32380,14 +32536,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:11437: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:11441:1: ( rule__ActorClass__Group_8_5__0__Impl rule__ActorClass__Group_8_5__1 )
+            // InternalRoom.g:11442: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 +32574,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:11449: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:11453:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:11454:1: ( 'usercode3' )
             {
-            // InternalRoom.g:11407:1: ( 'usercode3' )
-            // InternalRoom.g:11408:1: 'usercode3'
+            // InternalRoom.g:11454:1: ( 'usercode3' )
+            // InternalRoom.g:11455:1: 'usercode3'
             {
              before(grammarAccess.getActorClassAccess().getUsercode3Keyword_8_5_0()); 
             match(input,60,FOLLOW_2); 
@@ -32455,14 +32611,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:11468: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:11472:1: ( rule__ActorClass__Group_8_5__1__Impl )
+            // InternalRoom.g:11473:2: rule__ActorClass__Group_8_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_8_5__1__Impl();
@@ -32488,21 +32644,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:11479: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:11483:1: ( ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) ) )
+            // InternalRoom.g:11484: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:11484:1: ( ( rule__ActorClass__UserCode3Assignment_8_5_1 ) )
+            // InternalRoom.g:11485: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:11486:1: ( rule__ActorClass__UserCode3Assignment_8_5_1 )
+            // InternalRoom.g:11486:2: rule__ActorClass__UserCode3Assignment_8_5_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UserCode3Assignment_8_5_1();
@@ -32535,14 +32691,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:11500: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:11504:1: ( rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1 )
+            // InternalRoom.g:11505:2: rule__ActorClass__Group_9__0__Impl rule__ActorClass__Group_9__1
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_9__0__Impl();
@@ -32573,17 +32729,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:11512: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:11516:1: ( ( 'Behavior' ) )
+            // InternalRoom.g:11517:1: ( 'Behavior' )
             {
-            // InternalRoom.g:11470:1: ( 'Behavior' )
-            // InternalRoom.g:11471:1: 'Behavior'
+            // InternalRoom.g:11517:1: ( 'Behavior' )
+            // InternalRoom.g:11518:1: 'Behavior'
             {
              before(grammarAccess.getActorClassAccess().getBehaviorKeyword_9_0()); 
             match(input,76,FOLLOW_2); 
@@ -32610,14 +32766,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:11531: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:11535:1: ( rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2 )
+            // InternalRoom.g:11536:2: rule__ActorClass__Group_9__1__Impl rule__ActorClass__Group_9__2
             {
             pushFollow(FOLLOW_4);
             rule__ActorClass__Group_9__1__Impl();
@@ -32648,29 +32804,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:11543: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:11547:1: ( ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? ) )
+            // InternalRoom.g:11548: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:11548:1: ( ( rule__ActorClass__BehaviorDocuAssignment_9_1 )? )
+            // InternalRoom.g:11549: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:11550:1: ( rule__ActorClass__BehaviorDocuAssignment_9_1 )?
+            int alt124=2;
+            int LA124_0 = input.LA(1);
 
-            if ( (LA123_0==62) ) {
-                alt123=1;
+            if ( (LA124_0==62) ) {
+                alt124=1;
             }
-            switch (alt123) {
+            switch (alt124) {
                 case 1 :
-                    // InternalRoom.g:11503:2: rule__ActorClass__BehaviorDocuAssignment_9_1
+                    // InternalRoom.g:11550:2: rule__ActorClass__BehaviorDocuAssignment_9_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__BehaviorDocuAssignment_9_1();
@@ -32706,14 +32862,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:11560: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:11564:1: ( rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3 )
+            // InternalRoom.g:11565:2: rule__ActorClass__Group_9__2__Impl rule__ActorClass__Group_9__3
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__2__Impl();
@@ -32744,17 +32900,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:11572: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:11576:1: ( ( '{' ) )
+            // InternalRoom.g:11577:1: ( '{' )
             {
-            // InternalRoom.g:11530:1: ( '{' )
-            // InternalRoom.g:11531:1: '{'
+            // InternalRoom.g:11577:1: ( '{' )
+            // InternalRoom.g:11578:1: '{'
             {
              before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_9_2()); 
             match(input,44,FOLLOW_2); 
@@ -32781,14 +32937,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:11591: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:11595:1: ( rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4 )
+            // InternalRoom.g:11596:2: rule__ActorClass__Group_9__3__Impl rule__ActorClass__Group_9__4
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__3__Impl();
@@ -32819,33 +32975,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:11603: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:11607:1: ( ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* ) )
+            // InternalRoom.g:11608: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:11608:1: ( ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )* )
+            // InternalRoom.g:11609:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
             {
              before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAssignment_9_3()); 
-            // InternalRoom.g:11563:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
-            loop124:
+            // InternalRoom.g:11610:1: ( rule__ActorClass__BehaviorAnnotationsAssignment_9_3 )*
+            loop125:
             do {
-                int alt124=2;
-                int LA124_0 = input.LA(1);
+                int alt125=2;
+                int LA125_0 = input.LA(1);
 
-                if ( (LA124_0==121) ) {
-                    alt124=1;
+                if ( (LA125_0==121) ) {
+                    alt125=1;
                 }
 
 
-                switch (alt124) {
+                switch (alt125) {
             	case 1 :
-            	    // InternalRoom.g:11563:2: rule__ActorClass__BehaviorAnnotationsAssignment_9_3
+            	    // InternalRoom.g:11610:2: rule__ActorClass__BehaviorAnnotationsAssignment_9_3
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__ActorClass__BehaviorAnnotationsAssignment_9_3();
@@ -32857,7 +33013,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop124;
+            	    break loop125;
                 }
             } while (true);
 
@@ -32884,14 +33040,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:11620: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:11624:1: ( rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5 )
+            // InternalRoom.g:11625:2: rule__ActorClass__Group_9__4__Impl rule__ActorClass__Group_9__5
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__4__Impl();
@@ -32922,33 +33078,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:11632: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:11636:1: ( ( ( rule__ActorClass__Alternatives_9_4 )* ) )
+            // InternalRoom.g:11637: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:11637:1: ( ( rule__ActorClass__Alternatives_9_4 )* )
+            // InternalRoom.g:11638:1: ( rule__ActorClass__Alternatives_9_4 )*
             {
              before(grammarAccess.getActorClassAccess().getAlternatives_9_4()); 
-            // InternalRoom.g:11592:1: ( rule__ActorClass__Alternatives_9_4 )*
-            loop125:
+            // InternalRoom.g:11639:1: ( rule__ActorClass__Alternatives_9_4 )*
+            loop126:
             do {
-                int alt125=2;
-                int LA125_0 = input.LA(1);
+                int alt126=2;
+                int LA126_0 = input.LA(1);
 
-                if ( ((LA125_0>=14 && LA125_0<=15)||LA125_0==64||LA125_0==128) ) {
-                    alt125=1;
+                if ( ((LA126_0>=14 && LA126_0<=15)||LA126_0==64||LA126_0==128) ) {
+                    alt126=1;
                 }
 
 
-                switch (alt125) {
+                switch (alt126) {
             	case 1 :
-            	    // InternalRoom.g:11592:2: rule__ActorClass__Alternatives_9_4
+            	    // InternalRoom.g:11639:2: rule__ActorClass__Alternatives_9_4
             	    {
             	    pushFollow(FOLLOW_59);
             	    rule__ActorClass__Alternatives_9_4();
@@ -32960,7 +33116,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop125;
+            	    break loop126;
                 }
             } while (true);
 
@@ -32987,14 +33143,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:11649: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:11653:1: ( rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6 )
+            // InternalRoom.g:11654:2: rule__ActorClass__Group_9__5__Impl rule__ActorClass__Group_9__6
             {
             pushFollow(FOLLOW_58);
             rule__ActorClass__Group_9__5__Impl();
@@ -33025,29 +33181,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:11661: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:11665:1: ( ( ( rule__ActorClass__StateMachineAssignment_9_5 )? ) )
+            // InternalRoom.g:11666: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:11666:1: ( ( rule__ActorClass__StateMachineAssignment_9_5 )? )
+            // InternalRoom.g:11667: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:11668:1: ( rule__ActorClass__StateMachineAssignment_9_5 )?
+            int alt127=2;
+            int LA127_0 = input.LA(1);
 
-            if ( (LA126_0==94) ) {
-                alt126=1;
+            if ( (LA127_0==94) ) {
+                alt127=1;
             }
-            switch (alt126) {
+            switch (alt127) {
                 case 1 :
-                    // InternalRoom.g:11621:2: rule__ActorClass__StateMachineAssignment_9_5
+                    // InternalRoom.g:11668:2: rule__ActorClass__StateMachineAssignment_9_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__StateMachineAssignment_9_5();
@@ -33083,14 +33239,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:11678: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:11682:1: ( rule__ActorClass__Group_9__6__Impl )
+            // InternalRoom.g:11683:2: rule__ActorClass__Group_9__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__Group_9__6__Impl();
@@ -33116,17 +33272,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:11689: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:11693:1: ( ( '}' ) )
+            // InternalRoom.g:11694:1: ( '}' )
             {
-            // InternalRoom.g:11647:1: ( '}' )
-            // InternalRoom.g:11648:1: '}'
+            // InternalRoom.g:11694:1: ( '}' )
+            // InternalRoom.g:11695:1: '}'
             {
              before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_9_6()); 
             match(input,45,FOLLOW_2); 
@@ -33153,14 +33309,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:11722: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:11726:1: ( rule__Port__Group__0__Impl rule__Port__Group__1 )
+            // InternalRoom.g:11727:2: rule__Port__Group__0__Impl rule__Port__Group__1
             {
             pushFollow(FOLLOW_60);
             rule__Port__Group__0__Impl();
@@ -33191,29 +33347,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:11734: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:11738:1: ( ( ( rule__Port__ConjugatedAssignment_0 )? ) )
+            // InternalRoom.g:11739:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
             {
-            // InternalRoom.g:11692:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
-            // InternalRoom.g:11693:1: ( rule__Port__ConjugatedAssignment_0 )?
+            // InternalRoom.g:11739:1: ( ( rule__Port__ConjugatedAssignment_0 )? )
+            // InternalRoom.g:11740: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:11741:1: ( rule__Port__ConjugatedAssignment_0 )?
+            int alt128=2;
+            int LA128_0 = input.LA(1);
 
-            if ( (LA127_0==70) ) {
-                alt127=1;
+            if ( (LA128_0==70) ) {
+                alt128=1;
             }
-            switch (alt127) {
+            switch (alt128) {
                 case 1 :
-                    // InternalRoom.g:11694:2: rule__Port__ConjugatedAssignment_0
+                    // InternalRoom.g:11741:2: rule__Port__ConjugatedAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__ConjugatedAssignment_0();
@@ -33249,14 +33405,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:11751: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:11755:1: ( rule__Port__Group__1__Impl rule__Port__Group__2 )
+            // InternalRoom.g:11756:2: rule__Port__Group__1__Impl rule__Port__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__Port__Group__1__Impl();
@@ -33287,17 +33443,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:11763: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:11767:1: ( ( 'Port' ) )
+            // InternalRoom.g:11768:1: ( 'Port' )
             {
-            // InternalRoom.g:11721:1: ( 'Port' )
-            // InternalRoom.g:11722:1: 'Port'
+            // InternalRoom.g:11768:1: ( 'Port' )
+            // InternalRoom.g:11769:1: 'Port'
             {
              before(grammarAccess.getPortAccess().getPortKeyword_1()); 
             match(input,24,FOLLOW_2); 
@@ -33324,14 +33480,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:11782: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:11786:1: ( rule__Port__Group__2__Impl rule__Port__Group__3 )
+            // InternalRoom.g:11787:2: rule__Port__Group__2__Impl rule__Port__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__Port__Group__2__Impl();
@@ -33362,21 +33518,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:11794: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:11798:1: ( ( ( rule__Port__NameAssignment_2 ) ) )
+            // InternalRoom.g:11799:1: ( ( rule__Port__NameAssignment_2 ) )
             {
-            // InternalRoom.g:11752:1: ( ( rule__Port__NameAssignment_2 ) )
-            // InternalRoom.g:11753:1: ( rule__Port__NameAssignment_2 )
+            // InternalRoom.g:11799:1: ( ( rule__Port__NameAssignment_2 ) )
+            // InternalRoom.g:11800: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:11801:1: ( rule__Port__NameAssignment_2 )
+            // InternalRoom.g:11801:2: rule__Port__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Port__NameAssignment_2();
@@ -33409,14 +33565,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:11811: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:11815:1: ( rule__Port__Group__3__Impl rule__Port__Group__4 )
+            // InternalRoom.g:11816:2: rule__Port__Group__3__Impl rule__Port__Group__4
             {
             pushFollow(FOLLOW_28);
             rule__Port__Group__3__Impl();
@@ -33447,29 +33603,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:11823: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:11827:1: ( ( ( rule__Port__MultiplicityAssignment_3 )? ) )
+            // InternalRoom.g:11828:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
             {
-            // InternalRoom.g:11781:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
-            // InternalRoom.g:11782:1: ( rule__Port__MultiplicityAssignment_3 )?
+            // InternalRoom.g:11828:1: ( ( rule__Port__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:11829: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:11830:1: ( rule__Port__MultiplicityAssignment_3 )?
+            int alt129=2;
+            int LA129_0 = input.LA(1);
 
-            if ( (LA128_0==62) ) {
-                alt128=1;
+            if ( (LA129_0==62) ) {
+                alt129=1;
             }
-            switch (alt128) {
+            switch (alt129) {
                 case 1 :
-                    // InternalRoom.g:11783:2: rule__Port__MultiplicityAssignment_3
+                    // InternalRoom.g:11830:2: rule__Port__MultiplicityAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__MultiplicityAssignment_3();
@@ -33505,14 +33661,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:11840: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:11844:1: ( rule__Port__Group__4__Impl rule__Port__Group__5 )
+            // InternalRoom.g:11845:2: rule__Port__Group__4__Impl rule__Port__Group__5
             {
             pushFollow(FOLLOW_3);
             rule__Port__Group__4__Impl();
@@ -33543,17 +33699,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__Group__4__Impl"
-    // InternalRoom.g:11805:1: rule__Port__Group__4__Impl : ( ':' ) ;
+    // InternalRoom.g:11852: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:11856:1: ( ( ':' ) )
+            // InternalRoom.g:11857:1: ( ':' )
             {
-            // InternalRoom.g:11810:1: ( ':' )
-            // InternalRoom.g:11811:1: ':'
+            // InternalRoom.g:11857:1: ( ':' )
+            // InternalRoom.g:11858:1: ':'
             {
              before(grammarAccess.getPortAccess().getColonKeyword_4()); 
             match(input,46,FOLLOW_2); 
@@ -33580,14 +33736,14 @@ 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:11871: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:11875:1: ( rule__Port__Group__5__Impl rule__Port__Group__6 )
+            // InternalRoom.g:11876:2: rule__Port__Group__5__Impl rule__Port__Group__6
             {
             pushFollow(FOLLOW_47);
             rule__Port__Group__5__Impl();
@@ -33618,21 +33774,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:11883: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:11887:1: ( ( ( rule__Port__ProtocolAssignment_5 ) ) )
+            // InternalRoom.g:11888:1: ( ( rule__Port__ProtocolAssignment_5 ) )
             {
-            // InternalRoom.g:11841:1: ( ( rule__Port__ProtocolAssignment_5 ) )
-            // InternalRoom.g:11842:1: ( rule__Port__ProtocolAssignment_5 )
+            // InternalRoom.g:11888:1: ( ( rule__Port__ProtocolAssignment_5 ) )
+            // InternalRoom.g:11889: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:11890:1: ( rule__Port__ProtocolAssignment_5 )
+            // InternalRoom.g:11890:2: rule__Port__ProtocolAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__Port__ProtocolAssignment_5();
@@ -33665,14 +33821,14 @@ 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:11900: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:11904:1: ( rule__Port__Group__6__Impl rule__Port__Group__7 )
+            // InternalRoom.g:11905:2: rule__Port__Group__6__Impl rule__Port__Group__7
             {
             pushFollow(FOLLOW_47);
             rule__Port__Group__6__Impl();
@@ -33703,33 +33859,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:11912: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:11916:1: ( ( ( rule__Port__AnnotationsAssignment_6 )* ) )
+            // InternalRoom.g:11917:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
             {
-            // InternalRoom.g:11870:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
-            // InternalRoom.g:11871:1: ( rule__Port__AnnotationsAssignment_6 )*
+            // InternalRoom.g:11917:1: ( ( rule__Port__AnnotationsAssignment_6 )* )
+            // InternalRoom.g:11918:1: ( rule__Port__AnnotationsAssignment_6 )*
             {
              before(grammarAccess.getPortAccess().getAnnotationsAssignment_6()); 
-            // InternalRoom.g:11872:1: ( rule__Port__AnnotationsAssignment_6 )*
-            loop129:
+            // InternalRoom.g:11919:1: ( rule__Port__AnnotationsAssignment_6 )*
+            loop130:
             do {
-                int alt129=2;
-                int LA129_0 = input.LA(1);
+                int alt130=2;
+                int LA130_0 = input.LA(1);
 
-                if ( (LA129_0==121) ) {
-                    alt129=1;
+                if ( (LA130_0==121) ) {
+                    alt130=1;
                 }
 
 
-                switch (alt129) {
+                switch (alt130) {
             	case 1 :
-            	    // InternalRoom.g:11872:2: rule__Port__AnnotationsAssignment_6
+            	    // InternalRoom.g:11919:2: rule__Port__AnnotationsAssignment_6
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__Port__AnnotationsAssignment_6();
@@ -33741,7 +33897,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop129;
+            	    break loop130;
                 }
             } while (true);
 
@@ -33768,14 +33924,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:11929: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:11933:1: ( rule__Port__Group__7__Impl )
+            // InternalRoom.g:11934:2: rule__Port__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Port__Group__7__Impl();
@@ -33801,29 +33957,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:11940: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:11944:1: ( ( ( rule__Port__DocuAssignment_7 )? ) )
+            // InternalRoom.g:11945:1: ( ( rule__Port__DocuAssignment_7 )? )
             {
-            // InternalRoom.g:11898:1: ( ( rule__Port__DocuAssignment_7 )? )
-            // InternalRoom.g:11899:1: ( rule__Port__DocuAssignment_7 )?
+            // InternalRoom.g:11945:1: ( ( rule__Port__DocuAssignment_7 )? )
+            // InternalRoom.g:11946: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:11947:1: ( rule__Port__DocuAssignment_7 )?
+            int alt131=2;
+            int LA131_0 = input.LA(1);
 
-            if ( (LA130_0==62) ) {
-                alt130=1;
+            if ( (LA131_0==62) ) {
+                alt131=1;
             }
-            switch (alt130) {
+            switch (alt131) {
                 case 1 :
-                    // InternalRoom.g:11900:2: rule__Port__DocuAssignment_7
+                    // InternalRoom.g:11947:2: rule__Port__DocuAssignment_7
                     {
                     pushFollow(FOLLOW_2);
                     rule__Port__DocuAssignment_7();
@@ -33859,14 +34015,14 @@ 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:11973: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:11977:1: ( rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1 )
+            // InternalRoom.g:11978:2: rule__ExternalPort__Group__0__Impl rule__ExternalPort__Group__1
             {
             pushFollow(FOLLOW_61);
             rule__ExternalPort__Group__0__Impl();
@@ -33897,17 +34053,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:11985: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:11989:1: ( ( 'external' ) )
+            // InternalRoom.g:11990:1: ( 'external' )
             {
-            // InternalRoom.g:11943:1: ( 'external' )
-            // InternalRoom.g:11944:1: 'external'
+            // InternalRoom.g:11990:1: ( 'external' )
+            // InternalRoom.g:11991:1: 'external'
             {
              before(grammarAccess.getExternalPortAccess().getExternalKeyword_0()); 
             match(input,77,FOLLOW_2); 
@@ -33934,14 +34090,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:12004: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:12008:1: ( rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2 )
+            // InternalRoom.g:12009:2: rule__ExternalPort__Group__1__Impl rule__ExternalPort__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ExternalPort__Group__1__Impl();
@@ -33972,17 +34128,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:12016: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:12020:1: ( ( 'Port' ) )
+            // InternalRoom.g:12021:1: ( 'Port' )
             {
-            // InternalRoom.g:11974:1: ( 'Port' )
-            // InternalRoom.g:11975:1: 'Port'
+            // InternalRoom.g:12021:1: ( 'Port' )
+            // InternalRoom.g:12022:1: 'Port'
             {
              before(grammarAccess.getExternalPortAccess().getPortKeyword_1()); 
             match(input,24,FOLLOW_2); 
@@ -34009,14 +34165,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:12035: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:12039:1: ( rule__ExternalPort__Group__2__Impl )
+            // InternalRoom.g:12040:2: rule__ExternalPort__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExternalPort__Group__2__Impl();
@@ -34042,21 +34198,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:12046: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:12050:1: ( ( ( rule__ExternalPort__InterfacePortAssignment_2 ) ) )
+            // InternalRoom.g:12051:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
             {
-            // InternalRoom.g:12004:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
-            // InternalRoom.g:12005:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
+            // InternalRoom.g:12051:1: ( ( rule__ExternalPort__InterfacePortAssignment_2 ) )
+            // InternalRoom.g:12052: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:12053:1: ( rule__ExternalPort__InterfacePortAssignment_2 )
+            // InternalRoom.g:12053:2: rule__ExternalPort__InterfacePortAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ExternalPort__InterfacePortAssignment_2();
@@ -34089,14 +34245,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:12069: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:12073:1: ( rule__SAP__Group__0__Impl rule__SAP__Group__1 )
+            // InternalRoom.g:12074:2: rule__SAP__Group__0__Impl rule__SAP__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SAP__Group__0__Impl();
@@ -34127,17 +34283,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:12081: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:12085:1: ( ( 'SAP' ) )
+            // InternalRoom.g:12086:1: ( 'SAP' )
             {
-            // InternalRoom.g:12039:1: ( 'SAP' )
-            // InternalRoom.g:12040:1: 'SAP'
+            // InternalRoom.g:12086:1: ( 'SAP' )
+            // InternalRoom.g:12087:1: 'SAP'
             {
              before(grammarAccess.getSAPAccess().getSAPKeyword_0()); 
             match(input,78,FOLLOW_2); 
@@ -34164,14 +34320,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:12100: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:12104:1: ( rule__SAP__Group__1__Impl rule__SAP__Group__2 )
+            // InternalRoom.g:12105:2: rule__SAP__Group__1__Impl rule__SAP__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SAP__Group__1__Impl();
@@ -34202,21 +34358,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:12112: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:12116:1: ( ( ( rule__SAP__NameAssignment_1 ) ) )
+            // InternalRoom.g:12117:1: ( ( rule__SAP__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12070:1: ( ( rule__SAP__NameAssignment_1 ) )
-            // InternalRoom.g:12071:1: ( rule__SAP__NameAssignment_1 )
+            // InternalRoom.g:12117:1: ( ( rule__SAP__NameAssignment_1 ) )
+            // InternalRoom.g:12118: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:12119:1: ( rule__SAP__NameAssignment_1 )
+            // InternalRoom.g:12119:2: rule__SAP__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SAP__NameAssignment_1();
@@ -34249,14 +34405,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:12129: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:12133:1: ( rule__SAP__Group__2__Impl rule__SAP__Group__3 )
+            // InternalRoom.g:12134:2: rule__SAP__Group__2__Impl rule__SAP__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SAP__Group__2__Impl();
@@ -34287,17 +34443,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__Group__2__Impl"
-    // InternalRoom.g:12094:1: rule__SAP__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12141: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:12145:1: ( ( ':' ) )
+            // InternalRoom.g:12146:1: ( ':' )
             {
-            // InternalRoom.g:12099:1: ( ':' )
-            // InternalRoom.g:12100:1: ':'
+            // InternalRoom.g:12146:1: ( ':' )
+            // InternalRoom.g:12147:1: ':'
             {
              before(grammarAccess.getSAPAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -34324,14 +34480,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:12160: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:12164:1: ( rule__SAP__Group__3__Impl )
+            // InternalRoom.g:12165:2: rule__SAP__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SAP__Group__3__Impl();
@@ -34357,21 +34513,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:12171: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:12175:1: ( ( ( rule__SAP__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:12176:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:12129:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
-            // InternalRoom.g:12130:1: ( rule__SAP__ProtocolAssignment_3 )
+            // InternalRoom.g:12176:1: ( ( rule__SAP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12177: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:12178:1: ( rule__SAP__ProtocolAssignment_3 )
+            // InternalRoom.g:12178:2: rule__SAP__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SAP__ProtocolAssignment_3();
@@ -34404,14 +34560,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:12196: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:12200:1: ( rule__SPP__Group__0__Impl rule__SPP__Group__1 )
+            // InternalRoom.g:12201:2: rule__SPP__Group__0__Impl rule__SPP__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SPP__Group__0__Impl();
@@ -34442,17 +34598,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:12208: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:12212:1: ( ( 'SPP' ) )
+            // InternalRoom.g:12213:1: ( 'SPP' )
             {
-            // InternalRoom.g:12166:1: ( 'SPP' )
-            // InternalRoom.g:12167:1: 'SPP'
+            // InternalRoom.g:12213:1: ( 'SPP' )
+            // InternalRoom.g:12214:1: 'SPP'
             {
              before(grammarAccess.getSPPAccess().getSPPKeyword_0()); 
             match(input,79,FOLLOW_2); 
@@ -34479,14 +34635,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:12227: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:12231:1: ( rule__SPP__Group__1__Impl rule__SPP__Group__2 )
+            // InternalRoom.g:12232:2: rule__SPP__Group__1__Impl rule__SPP__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SPP__Group__1__Impl();
@@ -34517,21 +34673,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:12239: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:12243:1: ( ( ( rule__SPP__NameAssignment_1 ) ) )
+            // InternalRoom.g:12244:1: ( ( rule__SPP__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12197:1: ( ( rule__SPP__NameAssignment_1 ) )
-            // InternalRoom.g:12198:1: ( rule__SPP__NameAssignment_1 )
+            // InternalRoom.g:12244:1: ( ( rule__SPP__NameAssignment_1 ) )
+            // InternalRoom.g:12245: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:12246:1: ( rule__SPP__NameAssignment_1 )
+            // InternalRoom.g:12246:2: rule__SPP__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SPP__NameAssignment_1();
@@ -34564,14 +34720,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:12256: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:12260:1: ( rule__SPP__Group__2__Impl rule__SPP__Group__3 )
+            // InternalRoom.g:12261:2: rule__SPP__Group__2__Impl rule__SPP__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SPP__Group__2__Impl();
@@ -34602,17 +34758,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__Group__2__Impl"
-    // InternalRoom.g:12221:1: rule__SPP__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12268: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:12272:1: ( ( ':' ) )
+            // InternalRoom.g:12273:1: ( ':' )
             {
-            // InternalRoom.g:12226:1: ( ':' )
-            // InternalRoom.g:12227:1: ':'
+            // InternalRoom.g:12273:1: ( ':' )
+            // InternalRoom.g:12274:1: ':'
             {
              before(grammarAccess.getSPPAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -34639,14 +34795,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:12287: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:12291:1: ( rule__SPP__Group__3__Impl )
+            // InternalRoom.g:12292:2: rule__SPP__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SPP__Group__3__Impl();
@@ -34672,21 +34828,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:12298: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:12302:1: ( ( ( rule__SPP__ProtocolAssignment_3 ) ) )
+            // InternalRoom.g:12303:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
             {
-            // InternalRoom.g:12256:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
-            // InternalRoom.g:12257:1: ( rule__SPP__ProtocolAssignment_3 )
+            // InternalRoom.g:12303:1: ( ( rule__SPP__ProtocolAssignment_3 ) )
+            // InternalRoom.g:12304: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:12305:1: ( rule__SPP__ProtocolAssignment_3 )
+            // InternalRoom.g:12305:2: rule__SPP__ProtocolAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SPP__ProtocolAssignment_3();
@@ -34719,14 +34875,14 @@ 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:12323: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:12327:1: ( rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1 )
+            // InternalRoom.g:12328:2: rule__ServiceImplementation__Group__0__Impl rule__ServiceImplementation__Group__1
             {
             pushFollow(FOLLOW_62);
             rule__ServiceImplementation__Group__0__Impl();
@@ -34757,17 +34913,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:12335: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:12339:1: ( ( 'ServiceImplementation' ) )
+            // InternalRoom.g:12340:1: ( 'ServiceImplementation' )
             {
-            // InternalRoom.g:12293:1: ( 'ServiceImplementation' )
-            // InternalRoom.g:12294:1: 'ServiceImplementation'
+            // InternalRoom.g:12340:1: ( 'ServiceImplementation' )
+            // InternalRoom.g:12341:1: 'ServiceImplementation'
             {
              before(grammarAccess.getServiceImplementationAccess().getServiceImplementationKeyword_0()); 
             match(input,80,FOLLOW_2); 
@@ -34794,14 +34950,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:12354: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:12358:1: ( rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2 )
+            // InternalRoom.g:12359:2: rule__ServiceImplementation__Group__1__Impl rule__ServiceImplementation__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ServiceImplementation__Group__1__Impl();
@@ -34832,17 +34988,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:12366: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:12370:1: ( ( 'of' ) )
+            // InternalRoom.g:12371:1: ( 'of' )
             {
-            // InternalRoom.g:12324:1: ( 'of' )
-            // InternalRoom.g:12325:1: 'of'
+            // InternalRoom.g:12371:1: ( 'of' )
+            // InternalRoom.g:12372:1: 'of'
             {
              before(grammarAccess.getServiceImplementationAccess().getOfKeyword_1()); 
             match(input,53,FOLLOW_2); 
@@ -34869,14 +35025,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:12385: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:12389:1: ( rule__ServiceImplementation__Group__2__Impl )
+            // InternalRoom.g:12390:2: rule__ServiceImplementation__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ServiceImplementation__Group__2__Impl();
@@ -34902,21 +35058,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:12396: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:12400:1: ( ( ( rule__ServiceImplementation__SppAssignment_2 ) ) )
+            // InternalRoom.g:12401:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
             {
-            // InternalRoom.g:12354:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
-            // InternalRoom.g:12355:1: ( rule__ServiceImplementation__SppAssignment_2 )
+            // InternalRoom.g:12401:1: ( ( rule__ServiceImplementation__SppAssignment_2 ) )
+            // InternalRoom.g:12402: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:12403:1: ( rule__ServiceImplementation__SppAssignment_2 )
+            // InternalRoom.g:12403:2: rule__ServiceImplementation__SppAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ServiceImplementation__SppAssignment_2();
@@ -34949,14 +35105,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:12419: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:12423:1: ( rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1 )
+            // InternalRoom.g:12424:2: rule__LogicalSystem__Group__0__Impl rule__LogicalSystem__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__LogicalSystem__Group__0__Impl();
@@ -34987,17 +35143,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:12431: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:12435:1: ( ( 'LogicalSystem' ) )
+            // InternalRoom.g:12436:1: ( 'LogicalSystem' )
             {
-            // InternalRoom.g:12389:1: ( 'LogicalSystem' )
-            // InternalRoom.g:12390:1: 'LogicalSystem'
+            // InternalRoom.g:12436:1: ( 'LogicalSystem' )
+            // InternalRoom.g:12437:1: 'LogicalSystem'
             {
              before(grammarAccess.getLogicalSystemAccess().getLogicalSystemKeyword_0()); 
             match(input,23,FOLLOW_2); 
@@ -35024,14 +35180,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:12450: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:12454:1: ( rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2 )
+            // InternalRoom.g:12455:2: rule__LogicalSystem__Group__1__Impl rule__LogicalSystem__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__LogicalSystem__Group__1__Impl();
@@ -35062,21 +35218,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:12462: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:12466:1: ( ( ( rule__LogicalSystem__NameAssignment_1 ) ) )
+            // InternalRoom.g:12467:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12420:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
-            // InternalRoom.g:12421:1: ( rule__LogicalSystem__NameAssignment_1 )
+            // InternalRoom.g:12467:1: ( ( rule__LogicalSystem__NameAssignment_1 ) )
+            // InternalRoom.g:12468: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:12469:1: ( rule__LogicalSystem__NameAssignment_1 )
+            // InternalRoom.g:12469:2: rule__LogicalSystem__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LogicalSystem__NameAssignment_1();
@@ -35109,14 +35265,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:12479: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:12483:1: ( rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3 )
+            // InternalRoom.g:12484:2: rule__LogicalSystem__Group__2__Impl rule__LogicalSystem__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__LogicalSystem__Group__2__Impl();
@@ -35147,29 +35303,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:12491: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:12495:1: ( ( ( rule__LogicalSystem__DocuAssignment_2 )? ) )
+            // InternalRoom.g:12496:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:12449:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
-            // InternalRoom.g:12450:1: ( rule__LogicalSystem__DocuAssignment_2 )?
+            // InternalRoom.g:12496:1: ( ( rule__LogicalSystem__DocuAssignment_2 )? )
+            // InternalRoom.g:12497: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:12498:1: ( rule__LogicalSystem__DocuAssignment_2 )?
+            int alt132=2;
+            int LA132_0 = input.LA(1);
 
-            if ( (LA131_0==62) ) {
-                alt131=1;
+            if ( (LA132_0==62) ) {
+                alt132=1;
             }
-            switch (alt131) {
+            switch (alt132) {
                 case 1 :
-                    // InternalRoom.g:12451:2: rule__LogicalSystem__DocuAssignment_2
+                    // InternalRoom.g:12498:2: rule__LogicalSystem__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__LogicalSystem__DocuAssignment_2();
@@ -35205,14 +35361,14 @@ 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:12508: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:12512:1: ( rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4 )
+            // InternalRoom.g:12513:2: rule__LogicalSystem__Group__3__Impl rule__LogicalSystem__Group__4
             {
             pushFollow(FOLLOW_63);
             rule__LogicalSystem__Group__3__Impl();
@@ -35243,17 +35399,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__3__Impl"
-    // InternalRoom.g:12473:1: rule__LogicalSystem__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:12520: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:12524:1: ( ( '{' ) )
+            // InternalRoom.g:12525:1: ( '{' )
             {
-            // InternalRoom.g:12478:1: ( '{' )
-            // InternalRoom.g:12479:1: '{'
+            // InternalRoom.g:12525:1: ( '{' )
+            // InternalRoom.g:12526:1: '{'
             {
              before(grammarAccess.getLogicalSystemAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -35280,14 +35436,14 @@ 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:12539: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:12543:1: ( rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5 )
+            // InternalRoom.g:12544:2: rule__LogicalSystem__Group__4__Impl rule__LogicalSystem__Group__5
             {
             pushFollow(FOLLOW_63);
             rule__LogicalSystem__Group__4__Impl();
@@ -35318,33 +35474,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:12551: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:12555:1: ( ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:12556:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:12509:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:12510:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
+            // InternalRoom.g:12556:1: ( ( rule__LogicalSystem__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:12557:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getLogicalSystemAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:12511:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
-            loop132:
+            // InternalRoom.g:12558:1: ( rule__LogicalSystem__AnnotationsAssignment_4 )*
+            loop133:
             do {
-                int alt132=2;
-                int LA132_0 = input.LA(1);
+                int alt133=2;
+                int LA133_0 = input.LA(1);
 
-                if ( (LA132_0==121) ) {
-                    alt132=1;
+                if ( (LA133_0==121) ) {
+                    alt133=1;
                 }
 
 
-                switch (alt132) {
+                switch (alt133) {
             	case 1 :
-            	    // InternalRoom.g:12511:2: rule__LogicalSystem__AnnotationsAssignment_4
+            	    // InternalRoom.g:12558:2: rule__LogicalSystem__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__LogicalSystem__AnnotationsAssignment_4();
@@ -35356,7 +35512,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop132;
+            	    break loop133;
                 }
             } while (true);
 
@@ -35383,14 +35539,14 @@ 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:12568: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:12572:1: ( rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6 )
+            // InternalRoom.g:12573:2: rule__LogicalSystem__Group__5__Impl rule__LogicalSystem__Group__6
             {
             pushFollow(FOLLOW_63);
             rule__LogicalSystem__Group__5__Impl();
@@ -35421,33 +35577,33 @@ 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:12580: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:12584:1: ( ( ( rule__LogicalSystem__Alternatives_5 )* ) )
+            // InternalRoom.g:12585:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
             {
-            // InternalRoom.g:12538:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
-            // InternalRoom.g:12539:1: ( rule__LogicalSystem__Alternatives_5 )*
+            // InternalRoom.g:12585:1: ( ( rule__LogicalSystem__Alternatives_5 )* )
+            // InternalRoom.g:12586:1: ( rule__LogicalSystem__Alternatives_5 )*
             {
              before(grammarAccess.getLogicalSystemAccess().getAlternatives_5()); 
-            // InternalRoom.g:12540:1: ( rule__LogicalSystem__Alternatives_5 )*
-            loop133:
+            // InternalRoom.g:12587:1: ( rule__LogicalSystem__Alternatives_5 )*
+            loop134:
             do {
-                int alt133=2;
-                int LA133_0 = input.LA(1);
+                int alt134=2;
+                int LA134_0 = input.LA(1);
 
-                if ( (LA133_0==81||LA133_0==85||LA133_0==89) ) {
-                    alt133=1;
+                if ( (LA134_0==81||LA134_0==85||LA134_0==89) ) {
+                    alt134=1;
                 }
 
 
-                switch (alt133) {
+                switch (alt134) {
             	case 1 :
-            	    // InternalRoom.g:12540:2: rule__LogicalSystem__Alternatives_5
+            	    // InternalRoom.g:12587:2: rule__LogicalSystem__Alternatives_5
             	    {
             	    pushFollow(FOLLOW_64);
             	    rule__LogicalSystem__Alternatives_5();
@@ -35459,7 +35615,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop133;
+            	    break loop134;
                 }
             } while (true);
 
@@ -35486,14 +35642,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:12597: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:12601:1: ( rule__LogicalSystem__Group__6__Impl )
+            // InternalRoom.g:12602:2: rule__LogicalSystem__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LogicalSystem__Group__6__Impl();
@@ -35519,17 +35675,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__Group__6__Impl"
-    // InternalRoom.g:12561:1: rule__LogicalSystem__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:12608: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:12612:1: ( ( '}' ) )
+            // InternalRoom.g:12613:1: ( '}' )
             {
-            // InternalRoom.g:12566:1: ( '}' )
-            // InternalRoom.g:12567:1: '}'
+            // InternalRoom.g:12613:1: ( '}' )
+            // InternalRoom.g:12614:1: '}'
             {
              before(grammarAccess.getLogicalSystemAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -35556,14 +35712,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:12641: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:12645:1: ( rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1 )
+            // InternalRoom.g:12646:2: rule__SubSystemRef__Group__0__Impl rule__SubSystemRef__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemRef__Group__0__Impl();
@@ -35594,17 +35750,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:12653: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:12657:1: ( ( 'SubSystemRef' ) )
+            // InternalRoom.g:12658:1: ( 'SubSystemRef' )
             {
-            // InternalRoom.g:12611:1: ( 'SubSystemRef' )
-            // InternalRoom.g:12612:1: 'SubSystemRef'
+            // InternalRoom.g:12658:1: ( 'SubSystemRef' )
+            // InternalRoom.g:12659:1: 'SubSystemRef'
             {
              before(grammarAccess.getSubSystemRefAccess().getSubSystemRefKeyword_0()); 
             match(input,81,FOLLOW_2); 
@@ -35631,14 +35787,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:12672: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:12676:1: ( rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2 )
+            // InternalRoom.g:12677:2: rule__SubSystemRef__Group__1__Impl rule__SubSystemRef__Group__2
             {
             pushFollow(FOLLOW_8);
             rule__SubSystemRef__Group__1__Impl();
@@ -35669,21 +35825,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:12684: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:12688:1: ( ( ( rule__SubSystemRef__NameAssignment_1 ) ) )
+            // InternalRoom.g:12689:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12642:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
-            // InternalRoom.g:12643:1: ( rule__SubSystemRef__NameAssignment_1 )
+            // InternalRoom.g:12689:1: ( ( rule__SubSystemRef__NameAssignment_1 ) )
+            // InternalRoom.g:12690: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:12691:1: ( rule__SubSystemRef__NameAssignment_1 )
+            // InternalRoom.g:12691:2: rule__SubSystemRef__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__NameAssignment_1();
@@ -35716,14 +35872,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:12701: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:12705:1: ( rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3 )
+            // InternalRoom.g:12706:2: rule__SubSystemRef__Group__2__Impl rule__SubSystemRef__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemRef__Group__2__Impl();
@@ -35754,17 +35910,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__Group__2__Impl"
-    // InternalRoom.g:12666:1: rule__SubSystemRef__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:12713: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:12717:1: ( ( ':' ) )
+            // InternalRoom.g:12718:1: ( ':' )
             {
-            // InternalRoom.g:12671:1: ( ':' )
-            // InternalRoom.g:12672:1: ':'
+            // InternalRoom.g:12718:1: ( ':' )
+            // InternalRoom.g:12719:1: ':'
             {
              before(grammarAccess.getSubSystemRefAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -35791,14 +35947,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:12732: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:12736:1: ( rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4 )
+            // InternalRoom.g:12737:2: rule__SubSystemRef__Group__3__Impl rule__SubSystemRef__Group__4
             {
             pushFollow(FOLLOW_14);
             rule__SubSystemRef__Group__3__Impl();
@@ -35829,21 +35985,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:12744: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:12748:1: ( ( ( rule__SubSystemRef__TypeAssignment_3 ) ) )
+            // InternalRoom.g:12749:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
             {
-            // InternalRoom.g:12702:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
-            // InternalRoom.g:12703:1: ( rule__SubSystemRef__TypeAssignment_3 )
+            // InternalRoom.g:12749:1: ( ( rule__SubSystemRef__TypeAssignment_3 ) )
+            // InternalRoom.g:12750: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:12751:1: ( rule__SubSystemRef__TypeAssignment_3 )
+            // InternalRoom.g:12751:2: rule__SubSystemRef__TypeAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__TypeAssignment_3();
@@ -35876,14 +36032,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:12761: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:12765:1: ( rule__SubSystemRef__Group__4__Impl )
+            // InternalRoom.g:12766:2: rule__SubSystemRef__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemRef__Group__4__Impl();
@@ -35909,29 +36065,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:12772: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:12776:1: ( ( ( rule__SubSystemRef__DocuAssignment_4 )? ) )
+            // InternalRoom.g:12777:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
             {
-            // InternalRoom.g:12730:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
-            // InternalRoom.g:12731:1: ( rule__SubSystemRef__DocuAssignment_4 )?
+            // InternalRoom.g:12777:1: ( ( rule__SubSystemRef__DocuAssignment_4 )? )
+            // InternalRoom.g:12778: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:12779:1: ( rule__SubSystemRef__DocuAssignment_4 )?
+            int alt135=2;
+            int LA135_0 = input.LA(1);
 
-            if ( (LA134_0==62) ) {
-                alt134=1;
+            if ( (LA135_0==62) ) {
+                alt135=1;
             }
-            switch (alt134) {
+            switch (alt135) {
                 case 1 :
-                    // InternalRoom.g:12732:2: rule__SubSystemRef__DocuAssignment_4
+                    // InternalRoom.g:12779:2: rule__SubSystemRef__DocuAssignment_4
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemRef__DocuAssignment_4();
@@ -35967,14 +36123,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:12799: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:12803:1: ( rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1 )
+            // InternalRoom.g:12804:2: rule__SubSystemClass__Group__0__Impl rule__SubSystemClass__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SubSystemClass__Group__0__Impl();
@@ -36005,17 +36161,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:12811: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:12815:1: ( ( 'SubSystemClass' ) )
+            // InternalRoom.g:12816:1: ( 'SubSystemClass' )
             {
-            // InternalRoom.g:12769:1: ( 'SubSystemClass' )
-            // InternalRoom.g:12770:1: 'SubSystemClass'
+            // InternalRoom.g:12816:1: ( 'SubSystemClass' )
+            // InternalRoom.g:12817:1: 'SubSystemClass'
             {
              before(grammarAccess.getSubSystemClassAccess().getSubSystemClassKeyword_0()); 
             match(input,22,FOLLOW_2); 
@@ -36042,14 +36198,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:12830: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:12834:1: ( rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2 )
+            // InternalRoom.g:12835:2: rule__SubSystemClass__Group__1__Impl rule__SubSystemClass__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__SubSystemClass__Group__1__Impl();
@@ -36080,21 +36236,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:12842: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:12846:1: ( ( ( rule__SubSystemClass__NameAssignment_1 ) ) )
+            // InternalRoom.g:12847:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
             {
-            // InternalRoom.g:12800:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
-            // InternalRoom.g:12801:1: ( rule__SubSystemClass__NameAssignment_1 )
+            // InternalRoom.g:12847:1: ( ( rule__SubSystemClass__NameAssignment_1 ) )
+            // InternalRoom.g:12848: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:12849:1: ( rule__SubSystemClass__NameAssignment_1 )
+            // InternalRoom.g:12849:2: rule__SubSystemClass__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__NameAssignment_1();
@@ -36127,14 +36283,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:12859: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:12863:1: ( rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3 )
+            // InternalRoom.g:12864:2: rule__SubSystemClass__Group__2__Impl rule__SubSystemClass__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__SubSystemClass__Group__2__Impl();
@@ -36165,29 +36321,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:12871: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:12875:1: ( ( ( rule__SubSystemClass__DocuAssignment_2 )? ) )
+            // InternalRoom.g:12876:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:12829:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
-            // InternalRoom.g:12830:1: ( rule__SubSystemClass__DocuAssignment_2 )?
+            // InternalRoom.g:12876:1: ( ( rule__SubSystemClass__DocuAssignment_2 )? )
+            // InternalRoom.g:12877: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:12878:1: ( rule__SubSystemClass__DocuAssignment_2 )?
+            int alt136=2;
+            int LA136_0 = input.LA(1);
 
-            if ( (LA135_0==62) ) {
-                alt135=1;
+            if ( (LA136_0==62) ) {
+                alt136=1;
             }
-            switch (alt135) {
+            switch (alt136) {
                 case 1 :
-                    // InternalRoom.g:12831:2: rule__SubSystemClass__DocuAssignment_2
+                    // InternalRoom.g:12878:2: rule__SubSystemClass__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__DocuAssignment_2();
@@ -36223,14 +36379,14 @@ 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:12888: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:12892:1: ( rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4 )
+            // InternalRoom.g:12893:2: rule__SubSystemClass__Group__3__Impl rule__SubSystemClass__Group__4
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__3__Impl();
@@ -36261,17 +36417,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__3__Impl"
-    // InternalRoom.g:12853:1: rule__SubSystemClass__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:12900: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:12904:1: ( ( '{' ) )
+            // InternalRoom.g:12905:1: ( '{' )
             {
-            // InternalRoom.g:12858:1: ( '{' )
-            // InternalRoom.g:12859:1: '{'
+            // InternalRoom.g:12905:1: ( '{' )
+            // InternalRoom.g:12906:1: '{'
             {
              before(grammarAccess.getSubSystemClassAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -36298,14 +36454,14 @@ 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:12919: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:12923:1: ( rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5 )
+            // InternalRoom.g:12924:2: rule__SubSystemClass__Group__4__Impl rule__SubSystemClass__Group__5
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__4__Impl();
@@ -36336,33 +36492,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:12931: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:12935:1: ( ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* ) )
+            // InternalRoom.g:12936:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
             {
-            // InternalRoom.g:12889:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
-            // InternalRoom.g:12890:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
+            // InternalRoom.g:12936:1: ( ( rule__SubSystemClass__AnnotationsAssignment_4 )* )
+            // InternalRoom.g:12937:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
             {
              before(grammarAccess.getSubSystemClassAccess().getAnnotationsAssignment_4()); 
-            // InternalRoom.g:12891:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
-            loop136:
+            // InternalRoom.g:12938:1: ( rule__SubSystemClass__AnnotationsAssignment_4 )*
+            loop137:
             do {
-                int alt136=2;
-                int LA136_0 = input.LA(1);
+                int alt137=2;
+                int LA137_0 = input.LA(1);
 
-                if ( (LA136_0==121) ) {
-                    alt136=1;
+                if ( (LA137_0==121) ) {
+                    alt137=1;
                 }
 
 
-                switch (alt136) {
+                switch (alt137) {
             	case 1 :
-            	    // InternalRoom.g:12891:2: rule__SubSystemClass__AnnotationsAssignment_4
+            	    // InternalRoom.g:12938:2: rule__SubSystemClass__AnnotationsAssignment_4
             	    {
             	    pushFollow(FOLLOW_25);
             	    rule__SubSystemClass__AnnotationsAssignment_4();
@@ -36374,7 +36530,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop136;
+            	    break loop137;
                 }
             } while (true);
 
@@ -36401,14 +36557,14 @@ 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:12948: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:12952:1: ( rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6 )
+            // InternalRoom.g:12953:2: rule__SubSystemClass__Group__5__Impl rule__SubSystemClass__Group__6
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__5__Impl();
@@ -36439,29 +36595,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:12960: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:12964:1: ( ( ( rule__SubSystemClass__Group_5__0 )? ) )
+            // InternalRoom.g:12965: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:12965:1: ( ( rule__SubSystemClass__Group_5__0 )? )
+            // InternalRoom.g:12966: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:12967:1: ( rule__SubSystemClass__Group_5__0 )?
+            int alt138=2;
+            int LA138_0 = input.LA(1);
 
-            if ( (LA137_0==58) ) {
-                alt137=1;
+            if ( (LA138_0==58) ) {
+                alt138=1;
             }
-            switch (alt137) {
+            switch (alt138) {
                 case 1 :
-                    // InternalRoom.g:12920:2: rule__SubSystemClass__Group_5__0
+                    // InternalRoom.g:12967:2: rule__SubSystemClass__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_5__0();
@@ -36497,14 +36653,14 @@ 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:12977: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:12981:1: ( rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7 )
+            // InternalRoom.g:12982:2: rule__SubSystemClass__Group__6__Impl rule__SubSystemClass__Group__7
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__6__Impl();
@@ -36535,29 +36691,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:12989: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:12993:1: ( ( ( rule__SubSystemClass__Group_6__0 )? ) )
+            // InternalRoom.g:12994: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:12994:1: ( ( rule__SubSystemClass__Group_6__0 )? )
+            // InternalRoom.g:12995: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:12996:1: ( rule__SubSystemClass__Group_6__0 )?
+            int alt139=2;
+            int LA139_0 = input.LA(1);
 
-            if ( (LA138_0==59) ) {
-                alt138=1;
+            if ( (LA139_0==59) ) {
+                alt139=1;
             }
-            switch (alt138) {
+            switch (alt139) {
                 case 1 :
-                    // InternalRoom.g:12949:2: rule__SubSystemClass__Group_6__0
+                    // InternalRoom.g:12996:2: rule__SubSystemClass__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_6__0();
@@ -36593,14 +36749,14 @@ 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:13006: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:13010:1: ( rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8 )
+            // InternalRoom.g:13011:2: rule__SubSystemClass__Group__7__Impl rule__SubSystemClass__Group__8
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__7__Impl();
@@ -36631,29 +36787,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:13018: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:13022:1: ( ( ( rule__SubSystemClass__Group_7__0 )? ) )
+            // InternalRoom.g:13023: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:13023:1: ( ( rule__SubSystemClass__Group_7__0 )? )
+            // InternalRoom.g:13024: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:13025:1: ( rule__SubSystemClass__Group_7__0 )?
+            int alt140=2;
+            int LA140_0 = input.LA(1);
 
-            if ( (LA139_0==60) ) {
-                alt139=1;
+            if ( (LA140_0==60) ) {
+                alt140=1;
             }
-            switch (alt139) {
+            switch (alt140) {
                 case 1 :
-                    // InternalRoom.g:12978:2: rule__SubSystemClass__Group_7__0
+                    // InternalRoom.g:13025:2: rule__SubSystemClass__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SubSystemClass__Group_7__0();
@@ -36689,14 +36845,14 @@ 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:13035: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:13039:1: ( rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9 )
+            // InternalRoom.g:13040:2: rule__SubSystemClass__Group__8__Impl rule__SubSystemClass__Group__9
             {
             pushFollow(FOLLOW_65);
             rule__SubSystemClass__Group__8__Impl();
@@ -36727,33 +36883,33 @@ 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:13047: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:13051:1: ( ( ( rule__SubSystemClass__Alternatives_8 )* ) )
+            // InternalRoom.g:13052:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
             {
-            // InternalRoom.g:13005:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
-            // InternalRoom.g:13006:1: ( rule__SubSystemClass__Alternatives_8 )*
+            // InternalRoom.g:13052:1: ( ( rule__SubSystemClass__Alternatives_8 )* )
+            // InternalRoom.g:13053:1: ( rule__SubSystemClass__Alternatives_8 )*
             {
              before(grammarAccess.getSubSystemClassAccess().getAlternatives_8()); 
-            // InternalRoom.g:13007:1: ( rule__SubSystemClass__Alternatives_8 )*
-            loop140:
+            // InternalRoom.g:13054:1: ( rule__SubSystemClass__Alternatives_8 )*
+            loop141:
             do {
-                int alt140=2;
-                int LA140_0 = input.LA(1);
+                int alt141=2;
+                int LA141_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 ( (LA141_0==24||(LA141_0>=36 && LA141_0<=37)||LA141_0==70||LA141_0==79||(LA141_0>=82 && LA141_0<=83)||LA141_0==85||LA141_0==89||LA141_0==93) ) {
+                    alt141=1;
                 }
 
 
-                switch (alt140) {
+                switch (alt141) {
             	case 1 :
-            	    // InternalRoom.g:13007:2: rule__SubSystemClass__Alternatives_8
+            	    // InternalRoom.g:13054:2: rule__SubSystemClass__Alternatives_8
             	    {
             	    pushFollow(FOLLOW_66);
             	    rule__SubSystemClass__Alternatives_8();
@@ -36765,7 +36921,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop140;
+            	    break loop141;
                 }
             } while (true);
 
@@ -36792,14 +36948,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:13064: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:13068:1: ( rule__SubSystemClass__Group__9__Impl )
+            // InternalRoom.g:13069:2: rule__SubSystemClass__Group__9__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group__9__Impl();
@@ -36825,17 +36981,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__Group__9__Impl"
-    // InternalRoom.g:13028:1: rule__SubSystemClass__Group__9__Impl : ( '}' ) ;
+    // InternalRoom.g:13075: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:13079:1: ( ( '}' ) )
+            // InternalRoom.g:13080:1: ( '}' )
             {
-            // InternalRoom.g:13033:1: ( '}' )
-            // InternalRoom.g:13034:1: '}'
+            // InternalRoom.g:13080:1: ( '}' )
+            // InternalRoom.g:13081:1: '}'
             {
              before(grammarAccess.getSubSystemClassAccess().getRightCurlyBracketKeyword_9()); 
             match(input,45,FOLLOW_2); 
@@ -36862,14 +37018,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:13114: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:13118:1: ( rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1 )
+            // InternalRoom.g:13119:2: rule__SubSystemClass__Group_5__0__Impl rule__SubSystemClass__Group_5__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_5__0__Impl();
@@ -36900,17 +37056,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:13126: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:13130:1: ( ( 'usercode1' ) )
+            // InternalRoom.g:13131:1: ( 'usercode1' )
             {
-            // InternalRoom.g:13084:1: ( 'usercode1' )
-            // InternalRoom.g:13085:1: 'usercode1'
+            // InternalRoom.g:13131:1: ( 'usercode1' )
+            // InternalRoom.g:13132:1: 'usercode1'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode1Keyword_5_0()); 
             match(input,58,FOLLOW_2); 
@@ -36937,14 +37093,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:13145: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:13149:1: ( rule__SubSystemClass__Group_5__1__Impl )
+            // InternalRoom.g:13150:2: rule__SubSystemClass__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_5__1__Impl();
@@ -36970,21 +37126,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:13156: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:13160:1: ( ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) ) )
+            // InternalRoom.g:13161: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:13161:1: ( ( rule__SubSystemClass__UserCode1Assignment_5_1 ) )
+            // InternalRoom.g:13162: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:13163:1: ( rule__SubSystemClass__UserCode1Assignment_5_1 )
+            // InternalRoom.g:13163:2: rule__SubSystemClass__UserCode1Assignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode1Assignment_5_1();
@@ -37017,14 +37173,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:13177: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:13181:1: ( rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1 )
+            // InternalRoom.g:13182:2: rule__SubSystemClass__Group_6__0__Impl rule__SubSystemClass__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_6__0__Impl();
@@ -37055,17 +37211,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:13189: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:13193:1: ( ( 'usercode2' ) )
+            // InternalRoom.g:13194:1: ( 'usercode2' )
             {
-            // InternalRoom.g:13147:1: ( 'usercode2' )
-            // InternalRoom.g:13148:1: 'usercode2'
+            // InternalRoom.g:13194:1: ( 'usercode2' )
+            // InternalRoom.g:13195:1: 'usercode2'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode2Keyword_6_0()); 
             match(input,59,FOLLOW_2); 
@@ -37092,14 +37248,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:13208: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:13212:1: ( rule__SubSystemClass__Group_6__1__Impl )
+            // InternalRoom.g:13213:2: rule__SubSystemClass__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_6__1__Impl();
@@ -37125,21 +37281,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:13219: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:13223:1: ( ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) ) )
+            // InternalRoom.g:13224: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:13224:1: ( ( rule__SubSystemClass__UserCode2Assignment_6_1 ) )
+            // InternalRoom.g:13225: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:13226:1: ( rule__SubSystemClass__UserCode2Assignment_6_1 )
+            // InternalRoom.g:13226:2: rule__SubSystemClass__UserCode2Assignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode2Assignment_6_1();
@@ -37172,14 +37328,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:13240: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:13244:1: ( rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1 )
+            // InternalRoom.g:13245:2: rule__SubSystemClass__Group_7__0__Impl rule__SubSystemClass__Group_7__1
             {
             pushFollow(FOLLOW_27);
             rule__SubSystemClass__Group_7__0__Impl();
@@ -37210,17 +37366,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:13252: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:13256:1: ( ( 'usercode3' ) )
+            // InternalRoom.g:13257:1: ( 'usercode3' )
             {
-            // InternalRoom.g:13210:1: ( 'usercode3' )
-            // InternalRoom.g:13211:1: 'usercode3'
+            // InternalRoom.g:13257:1: ( 'usercode3' )
+            // InternalRoom.g:13258:1: 'usercode3'
             {
              before(grammarAccess.getSubSystemClassAccess().getUsercode3Keyword_7_0()); 
             match(input,60,FOLLOW_2); 
@@ -37247,14 +37403,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:13271: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:13275:1: ( rule__SubSystemClass__Group_7__1__Impl )
+            // InternalRoom.g:13276:2: rule__SubSystemClass__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__Group_7__1__Impl();
@@ -37280,21 +37436,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:13282: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:13286:1: ( ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) ) )
+            // InternalRoom.g:13287: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:13287:1: ( ( rule__SubSystemClass__UserCode3Assignment_7_1 ) )
+            // InternalRoom.g:13288: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:13289:1: ( rule__SubSystemClass__UserCode3Assignment_7_1 )
+            // InternalRoom.g:13289:2: rule__SubSystemClass__UserCode3Assignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__SubSystemClass__UserCode3Assignment_7_1();
@@ -37327,14 +37483,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:13303: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:13307:1: ( rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1 )
+            // InternalRoom.g:13308:2: rule__LogicalThread__Group__0__Impl rule__LogicalThread__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__LogicalThread__Group__0__Impl();
@@ -37365,17 +37521,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:13315: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:13319:1: ( ( 'LogicalThread' ) )
+            // InternalRoom.g:13320:1: ( 'LogicalThread' )
             {
-            // InternalRoom.g:13273:1: ( 'LogicalThread' )
-            // InternalRoom.g:13274:1: 'LogicalThread'
+            // InternalRoom.g:13320:1: ( 'LogicalThread' )
+            // InternalRoom.g:13321:1: 'LogicalThread'
             {
              before(grammarAccess.getLogicalThreadAccess().getLogicalThreadKeyword_0()); 
             match(input,82,FOLLOW_2); 
@@ -37402,14 +37558,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:13334: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:13338:1: ( rule__LogicalThread__Group__1__Impl )
+            // InternalRoom.g:13339:2: rule__LogicalThread__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LogicalThread__Group__1__Impl();
@@ -37435,21 +37591,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:13345: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:13349:1: ( ( ( rule__LogicalThread__NameAssignment_1 ) ) )
+            // InternalRoom.g:13350:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
             {
-            // InternalRoom.g:13303:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
-            // InternalRoom.g:13304:1: ( rule__LogicalThread__NameAssignment_1 )
+            // InternalRoom.g:13350:1: ( ( rule__LogicalThread__NameAssignment_1 ) )
+            // InternalRoom.g:13351: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:13352:1: ( rule__LogicalThread__NameAssignment_1 )
+            // InternalRoom.g:13352:2: rule__LogicalThread__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LogicalThread__NameAssignment_1();
@@ -37482,14 +37638,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:13366: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:13370:1: ( rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1 )
+            // InternalRoom.g:13371:2: rule__ActorInstanceMapping__Group__0__Impl rule__ActorInstanceMapping__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ActorInstanceMapping__Group__0__Impl();
@@ -37520,17 +37676,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:13378: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:13382:1: ( ( 'ActorInstanceMapping' ) )
+            // InternalRoom.g:13383:1: ( 'ActorInstanceMapping' )
             {
-            // InternalRoom.g:13336:1: ( 'ActorInstanceMapping' )
-            // InternalRoom.g:13337:1: 'ActorInstanceMapping'
+            // InternalRoom.g:13383:1: ( 'ActorInstanceMapping' )
+            // InternalRoom.g:13384:1: 'ActorInstanceMapping'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingKeyword_0()); 
             match(input,83,FOLLOW_2); 
@@ -37557,14 +37713,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:13397: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:13401:1: ( rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2 )
+            // InternalRoom.g:13402:2: rule__ActorInstanceMapping__Group__1__Impl rule__ActorInstanceMapping__Group__2
             {
             pushFollow(FOLLOW_11);
             rule__ActorInstanceMapping__Group__1__Impl();
@@ -37595,21 +37751,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:13409: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:13413:1: ( ( ( rule__ActorInstanceMapping__PathAssignment_1 ) ) )
+            // InternalRoom.g:13414:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
             {
-            // InternalRoom.g:13367:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
-            // InternalRoom.g:13368:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
+            // InternalRoom.g:13414:1: ( ( rule__ActorInstanceMapping__PathAssignment_1 ) )
+            // InternalRoom.g:13415: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:13416:1: ( rule__ActorInstanceMapping__PathAssignment_1 )
+            // InternalRoom.g:13416:2: rule__ActorInstanceMapping__PathAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__PathAssignment_1();
@@ -37642,14 +37798,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:13426: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:13430:1: ( rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3 )
+            // InternalRoom.g:13431:2: rule__ActorInstanceMapping__Group__2__Impl rule__ActorInstanceMapping__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__ActorInstanceMapping__Group__2__Impl();
@@ -37680,17 +37836,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__Group__2__Impl"
-    // InternalRoom.g:13391:1: rule__ActorInstanceMapping__Group__2__Impl : ( '->' ) ;
+    // InternalRoom.g:13438: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:13442:1: ( ( '->' ) )
+            // InternalRoom.g:13443:1: ( '->' )
             {
-            // InternalRoom.g:13396:1: ( '->' )
-            // InternalRoom.g:13397:1: '->'
+            // InternalRoom.g:13443:1: ( '->' )
+            // InternalRoom.g:13444:1: '->'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getHyphenMinusGreaterThanSignKeyword_2()); 
             match(input,48,FOLLOW_2); 
@@ -37717,14 +37873,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:13457: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:13461:1: ( rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4 )
+            // InternalRoom.g:13462:2: rule__ActorInstanceMapping__Group__3__Impl rule__ActorInstanceMapping__Group__4
             {
             pushFollow(FOLLOW_40);
             rule__ActorInstanceMapping__Group__3__Impl();
@@ -37755,21 +37911,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:13469: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:13473:1: ( ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) ) )
+            // InternalRoom.g:13474:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
             {
-            // InternalRoom.g:13427:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
-            // InternalRoom.g:13428:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
+            // InternalRoom.g:13474:1: ( ( rule__ActorInstanceMapping__ThreadAssignment_3 ) )
+            // InternalRoom.g:13475: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:13476:1: ( rule__ActorInstanceMapping__ThreadAssignment_3 )
+            // InternalRoom.g:13476:2: rule__ActorInstanceMapping__ThreadAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__ThreadAssignment_3();
@@ -37802,14 +37958,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:13486: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:13490:1: ( rule__ActorInstanceMapping__Group__4__Impl )
+            // InternalRoom.g:13491:2: rule__ActorInstanceMapping__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__Group__4__Impl();
@@ -37835,29 +37991,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:13497: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:13501:1: ( ( ( rule__ActorInstanceMapping__Group_4__0 )? ) )
+            // InternalRoom.g:13502: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:13502:1: ( ( rule__ActorInstanceMapping__Group_4__0 )? )
+            // InternalRoom.g:13503: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:13504:1: ( rule__ActorInstanceMapping__Group_4__0 )?
+            int alt142=2;
+            int LA142_0 = input.LA(1);
 
-            if ( (LA141_0==44) ) {
-                alt141=1;
+            if ( (LA142_0==44) ) {
+                alt142=1;
             }
-            switch (alt141) {
+            switch (alt142) {
                 case 1 :
-                    // InternalRoom.g:13457:2: rule__ActorInstanceMapping__Group_4__0
+                    // InternalRoom.g:13504:2: rule__ActorInstanceMapping__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorInstanceMapping__Group_4__0();
@@ -37893,14 +38049,14 @@ 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:13524: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:13528:1: ( rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1 )
+            // InternalRoom.g:13529:2: rule__ActorInstanceMapping__Group_4__0__Impl rule__ActorInstanceMapping__Group_4__1
             {
             pushFollow(FOLLOW_67);
             rule__ActorInstanceMapping__Group_4__0__Impl();
@@ -37931,17 +38087,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:13536: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:13540:1: ( ( '{' ) )
+            // InternalRoom.g:13541:1: ( '{' )
             {
-            // InternalRoom.g:13494:1: ( '{' )
-            // InternalRoom.g:13495:1: '{'
+            // InternalRoom.g:13541:1: ( '{' )
+            // InternalRoom.g:13542:1: '{'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0()); 
             match(input,44,FOLLOW_2); 
@@ -37968,14 +38124,14 @@ 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:13555: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:13559:1: ( rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2 )
+            // InternalRoom.g:13560:2: rule__ActorInstanceMapping__Group_4__1__Impl rule__ActorInstanceMapping__Group_4__2
             {
             pushFollow(FOLLOW_67);
             rule__ActorInstanceMapping__Group_4__1__Impl();
@@ -38006,33 +38162,33 @@ 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:13567: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:13571:1: ( ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* ) )
+            // InternalRoom.g:13572: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:13572:1: ( ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )* )
+            // InternalRoom.g:13573:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsAssignment_4_1()); 
-            // InternalRoom.g:13527:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
-            loop142:
+            // InternalRoom.g:13574:1: ( rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1 )*
+            loop143:
             do {
-                int alt142=2;
-                int LA142_0 = input.LA(1);
+                int alt143=2;
+                int LA143_0 = input.LA(1);
 
-                if ( (LA142_0==83) ) {
-                    alt142=1;
+                if ( (LA143_0==83) ) {
+                    alt143=1;
                 }
 
 
-                switch (alt142) {
+                switch (alt143) {
             	case 1 :
-            	    // InternalRoom.g:13527:2: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1
+            	    // InternalRoom.g:13574:2: rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1
             	    {
             	    pushFollow(FOLLOW_68);
             	    rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1();
@@ -38044,7 +38200,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop142;
+            	    break loop143;
                 }
             } while (true);
 
@@ -38071,14 +38227,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:13584: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:13588:1: ( rule__ActorInstanceMapping__Group_4__2__Impl )
+            // InternalRoom.g:13589:2: rule__ActorInstanceMapping__Group_4__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorInstanceMapping__Group_4__2__Impl();
@@ -38104,17 +38260,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:13595: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:13599:1: ( ( '}' ) )
+            // InternalRoom.g:13600:1: ( '}' )
             {
-            // InternalRoom.g:13553:1: ( '}' )
-            // InternalRoom.g:13554:1: '}'
+            // InternalRoom.g:13600:1: ( '}' )
+            // InternalRoom.g:13601:1: '}'
             {
              before(grammarAccess.getActorInstanceMappingAccess().getRightCurlyBracketKeyword_4_2()); 
             match(input,45,FOLLOW_2); 
@@ -38141,14 +38297,14 @@ 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:13620: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:13624:1: ( rule__RefPath__Group__0__Impl rule__RefPath__Group__1 )
+            // InternalRoom.g:13625:2: rule__RefPath__Group__0__Impl rule__RefPath__Group__1
             {
             pushFollow(FOLLOW_69);
             rule__RefPath__Group__0__Impl();
@@ -38179,21 +38335,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:13632: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:13636:1: ( ( ( rule__RefPath__RefsAssignment_0 ) ) )
+            // InternalRoom.g:13637:1: ( ( rule__RefPath__RefsAssignment_0 ) )
             {
-            // InternalRoom.g:13590:1: ( ( rule__RefPath__RefsAssignment_0 ) )
-            // InternalRoom.g:13591:1: ( rule__RefPath__RefsAssignment_0 )
+            // InternalRoom.g:13637:1: ( ( rule__RefPath__RefsAssignment_0 ) )
+            // InternalRoom.g:13638: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:13639:1: ( rule__RefPath__RefsAssignment_0 )
+            // InternalRoom.g:13639:2: rule__RefPath__RefsAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__RefsAssignment_0();
@@ -38226,14 +38382,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:13649: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:13653:1: ( rule__RefPath__Group__1__Impl )
+            // InternalRoom.g:13654:2: rule__RefPath__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__Group__1__Impl();
@@ -38259,33 +38415,33 @@ 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:13660: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:13664:1: ( ( ( rule__RefPath__Group_1__0 )* ) )
+            // InternalRoom.g:13665: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:13665:1: ( ( rule__RefPath__Group_1__0 )* )
+            // InternalRoom.g:13666:1: ( rule__RefPath__Group_1__0 )*
             {
              before(grammarAccess.getRefPathAccess().getGroup_1()); 
-            // InternalRoom.g:13620:1: ( rule__RefPath__Group_1__0 )*
-            loop143:
+            // InternalRoom.g:13667:1: ( rule__RefPath__Group_1__0 )*
+            loop144:
             do {
-                int alt143=2;
-                int LA143_0 = input.LA(1);
+                int alt144=2;
+                int LA144_0 = input.LA(1);
 
-                if ( (LA143_0==84) ) {
-                    alt143=1;
+                if ( (LA144_0==84) ) {
+                    alt144=1;
                 }
 
 
-                switch (alt143) {
+                switch (alt144) {
             	case 1 :
-            	    // InternalRoom.g:13620:2: rule__RefPath__Group_1__0
+            	    // InternalRoom.g:13667:2: rule__RefPath__Group_1__0
             	    {
             	    pushFollow(FOLLOW_70);
             	    rule__RefPath__Group_1__0();
@@ -38297,7 +38453,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop143;
+            	    break loop144;
                 }
             } while (true);
 
@@ -38324,14 +38480,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:13681: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:13685:1: ( rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1 )
+            // InternalRoom.g:13686:2: rule__RefPath__Group_1__0__Impl rule__RefPath__Group_1__1
             {
             pushFollow(FOLLOW_3);
             rule__RefPath__Group_1__0__Impl();
@@ -38362,17 +38518,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:13693: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:13697:1: ( ( '/' ) )
+            // InternalRoom.g:13698:1: ( '/' )
             {
-            // InternalRoom.g:13651:1: ( '/' )
-            // InternalRoom.g:13652:1: '/'
+            // InternalRoom.g:13698:1: ( '/' )
+            // InternalRoom.g:13699:1: '/'
             {
              before(grammarAccess.getRefPathAccess().getSolidusKeyword_1_0()); 
             match(input,84,FOLLOW_2); 
@@ -38399,14 +38555,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:13712: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:13716:1: ( rule__RefPath__Group_1__1__Impl )
+            // InternalRoom.g:13717:2: rule__RefPath__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__Group_1__1__Impl();
@@ -38432,21 +38588,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:13723: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:13727:1: ( ( ( rule__RefPath__RefsAssignment_1_1 ) ) )
+            // InternalRoom.g:13728: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:13728:1: ( ( rule__RefPath__RefsAssignment_1_1 ) )
+            // InternalRoom.g:13729: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:13730:1: ( rule__RefPath__RefsAssignment_1_1 )
+            // InternalRoom.g:13730:2: rule__RefPath__RefsAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__RefPath__RefsAssignment_1_1();
@@ -38479,14 +38635,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:13744: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:13748:1: ( rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1 )
+            // InternalRoom.g:13749:2: rule__RefSegment__Group__0__Impl rule__RefSegment__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__RefSegment__Group__0__Impl();
@@ -38517,21 +38673,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:13756: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:13760:1: ( ( ( rule__RefSegment__RefAssignment_0 ) ) )
+            // InternalRoom.g:13761:1: ( ( rule__RefSegment__RefAssignment_0 ) )
             {
-            // InternalRoom.g:13714:1: ( ( rule__RefSegment__RefAssignment_0 ) )
-            // InternalRoom.g:13715:1: ( rule__RefSegment__RefAssignment_0 )
+            // InternalRoom.g:13761:1: ( ( rule__RefSegment__RefAssignment_0 ) )
+            // InternalRoom.g:13762: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:13763:1: ( rule__RefSegment__RefAssignment_0 )
+            // InternalRoom.g:13763:2: rule__RefSegment__RefAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__RefAssignment_0();
@@ -38564,14 +38720,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:13773: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:13777:1: ( rule__RefSegment__Group__1__Impl )
+            // InternalRoom.g:13778:2: rule__RefSegment__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__Group__1__Impl();
@@ -38597,29 +38753,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:13784: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:13788:1: ( ( ( rule__RefSegment__Group_1__0 )? ) )
+            // InternalRoom.g:13789: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:13789:1: ( ( rule__RefSegment__Group_1__0 )? )
+            // InternalRoom.g:13790: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:13791:1: ( rule__RefSegment__Group_1__0 )?
+            int alt145=2;
+            int LA145_0 = input.LA(1);
 
-            if ( (LA144_0==46) ) {
-                alt144=1;
+            if ( (LA145_0==46) ) {
+                alt145=1;
             }
-            switch (alt144) {
+            switch (alt145) {
                 case 1 :
-                    // InternalRoom.g:13744:2: rule__RefSegment__Group_1__0
+                    // InternalRoom.g:13791:2: rule__RefSegment__Group_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefSegment__Group_1__0();
@@ -38655,14 +38811,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:13805: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:13809:1: ( rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1 )
+            // InternalRoom.g:13810:2: rule__RefSegment__Group_1__0__Impl rule__RefSegment__Group_1__1
             {
             pushFollow(FOLLOW_30);
             rule__RefSegment__Group_1__0__Impl();
@@ -38693,17 +38849,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:13817: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:13821:1: ( ( ':' ) )
+            // InternalRoom.g:13822:1: ( ':' )
             {
-            // InternalRoom.g:13775:1: ( ':' )
-            // InternalRoom.g:13776:1: ':'
+            // InternalRoom.g:13822:1: ( ':' )
+            // InternalRoom.g:13823:1: ':'
             {
              before(grammarAccess.getRefSegmentAccess().getColonKeyword_1_0()); 
             match(input,46,FOLLOW_2); 
@@ -38730,14 +38886,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:13836: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:13840:1: ( rule__RefSegment__Group_1__1__Impl )
+            // InternalRoom.g:13841:2: rule__RefSegment__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__Group_1__1__Impl();
@@ -38763,21 +38919,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:13847: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:13851:1: ( ( ( rule__RefSegment__IdxAssignment_1_1 ) ) )
+            // InternalRoom.g:13852: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:13852:1: ( ( rule__RefSegment__IdxAssignment_1_1 ) )
+            // InternalRoom.g:13853: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:13854:1: ( rule__RefSegment__IdxAssignment_1_1 )
+            // InternalRoom.g:13854:2: rule__RefSegment__IdxAssignment_1_1
             {
             pushFollow(FOLLOW_2);
             rule__RefSegment__IdxAssignment_1_1();
@@ -38810,14 +38966,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:13868: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:13872:1: ( rule__Binding__Group__0__Impl rule__Binding__Group__1 )
+            // InternalRoom.g:13873:2: rule__Binding__Group__0__Impl rule__Binding__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Binding__Group__0__Impl();
@@ -38848,17 +39004,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:13880: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:13884:1: ( ( 'Binding' ) )
+            // InternalRoom.g:13885:1: ( 'Binding' )
             {
-            // InternalRoom.g:13838:1: ( 'Binding' )
-            // InternalRoom.g:13839:1: 'Binding'
+            // InternalRoom.g:13885:1: ( 'Binding' )
+            // InternalRoom.g:13886:1: 'Binding'
             {
              before(grammarAccess.getBindingAccess().getBindingKeyword_0()); 
             match(input,85,FOLLOW_2); 
@@ -38885,14 +39041,14 @@ 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:13899: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:13903:1: ( rule__Binding__Group__1__Impl rule__Binding__Group__2 )
+            // InternalRoom.g:13904:2: rule__Binding__Group__1__Impl rule__Binding__Group__2
             {
             pushFollow(FOLLOW_71);
             rule__Binding__Group__1__Impl();
@@ -38923,21 +39079,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:13911: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:13915:1: ( ( ( rule__Binding__Endpoint1Assignment_1 ) ) )
+            // InternalRoom.g:13916:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
             {
-            // InternalRoom.g:13869:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
-            // InternalRoom.g:13870:1: ( rule__Binding__Endpoint1Assignment_1 )
+            // InternalRoom.g:13916:1: ( ( rule__Binding__Endpoint1Assignment_1 ) )
+            // InternalRoom.g:13917: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:13918:1: ( rule__Binding__Endpoint1Assignment_1 )
+            // InternalRoom.g:13918:2: rule__Binding__Endpoint1Assignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Endpoint1Assignment_1();
@@ -38970,14 +39126,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:13928: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:13932:1: ( rule__Binding__Group__2__Impl rule__Binding__Group__3 )
+            // InternalRoom.g:13933:2: rule__Binding__Group__2__Impl rule__Binding__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__Binding__Group__2__Impl();
@@ -39008,17 +39164,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:13940: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:13944:1: ( ( 'and' ) )
+            // InternalRoom.g:13945:1: ( 'and' )
             {
-            // InternalRoom.g:13898:1: ( 'and' )
-            // InternalRoom.g:13899:1: 'and'
+            // InternalRoom.g:13945:1: ( 'and' )
+            // InternalRoom.g:13946:1: 'and'
             {
              before(grammarAccess.getBindingAccess().getAndKeyword_2()); 
             match(input,86,FOLLOW_2); 
@@ -39045,14 +39201,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:13959: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:13963:1: ( rule__Binding__Group__3__Impl )
+            // InternalRoom.g:13964:2: rule__Binding__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Group__3__Impl();
@@ -39078,21 +39234,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:13970: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:13974:1: ( ( ( rule__Binding__Endpoint2Assignment_3 ) ) )
+            // InternalRoom.g:13975:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
             {
-            // InternalRoom.g:13928:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
-            // InternalRoom.g:13929:1: ( rule__Binding__Endpoint2Assignment_3 )
+            // InternalRoom.g:13975:1: ( ( rule__Binding__Endpoint2Assignment_3 ) )
+            // InternalRoom.g:13976: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:13977:1: ( rule__Binding__Endpoint2Assignment_3 )
+            // InternalRoom.g:13977:2: rule__Binding__Endpoint2Assignment_3
             {
             pushFollow(FOLLOW_2);
             rule__Binding__Endpoint2Assignment_3();
@@ -39125,14 +39281,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:13995: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:13999:1: ( rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1 )
+            // InternalRoom.g:14000:2: rule__BindingEndPoint__Group__0__Impl rule__BindingEndPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__BindingEndPoint__Group__0__Impl();
@@ -39163,33 +39319,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:14007: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:14011:1: ( ( ( rule__BindingEndPoint__Group_0__0 )? ) )
+            // InternalRoom.g:14012: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:14012:1: ( ( rule__BindingEndPoint__Group_0__0 )? )
+            // InternalRoom.g:14013: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:14014:1: ( rule__BindingEndPoint__Group_0__0 )?
+            int alt146=2;
+            int LA146_0 = input.LA(1);
 
-            if ( (LA145_0==RULE_ID) ) {
-                int LA145_1 = input.LA(2);
+            if ( (LA146_0==RULE_ID) ) {
+                int LA146_1 = input.LA(2);
 
-                if ( (LA145_1==87) ) {
-                    alt145=1;
+                if ( (LA146_1==87) ) {
+                    alt146=1;
                 }
             }
-            switch (alt145) {
+            switch (alt146) {
                 case 1 :
-                    // InternalRoom.g:13967:2: rule__BindingEndPoint__Group_0__0
+                    // InternalRoom.g:14014:2: rule__BindingEndPoint__Group_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__BindingEndPoint__Group_0__0();
@@ -39225,14 +39381,14 @@ 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:14024: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:14028:1: ( rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2 )
+            // InternalRoom.g:14029:2: rule__BindingEndPoint__Group__1__Impl rule__BindingEndPoint__Group__2
             {
             pushFollow(FOLLOW_72);
             rule__BindingEndPoint__Group__1__Impl();
@@ -39263,21 +39419,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:14036: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:14040:1: ( ( ( rule__BindingEndPoint__PortAssignment_1 ) ) )
+            // InternalRoom.g:14041:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
             {
-            // InternalRoom.g:13994:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
-            // InternalRoom.g:13995:1: ( rule__BindingEndPoint__PortAssignment_1 )
+            // InternalRoom.g:14041:1: ( ( rule__BindingEndPoint__PortAssignment_1 ) )
+            // InternalRoom.g:14042: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:14043:1: ( rule__BindingEndPoint__PortAssignment_1 )
+            // InternalRoom.g:14043:2: rule__BindingEndPoint__PortAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__PortAssignment_1();
@@ -39310,14 +39466,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:14053: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:14057:1: ( rule__BindingEndPoint__Group__2__Impl )
+            // InternalRoom.g:14058:2: rule__BindingEndPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group__2__Impl();
@@ -39343,29 +39499,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:14064: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:14068:1: ( ( ( rule__BindingEndPoint__Group_2__0 )? ) )
+            // InternalRoom.g:14069: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:14069:1: ( ( rule__BindingEndPoint__Group_2__0 )? )
+            // InternalRoom.g:14070: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:14071:1: ( rule__BindingEndPoint__Group_2__0 )?
+            int alt147=2;
+            int LA147_0 = input.LA(1);
 
-            if ( (LA146_0==88) ) {
-                alt146=1;
+            if ( (LA147_0==88) ) {
+                alt147=1;
             }
-            switch (alt146) {
+            switch (alt147) {
                 case 1 :
-                    // InternalRoom.g:14024:2: rule__BindingEndPoint__Group_2__0
+                    // InternalRoom.g:14071:2: rule__BindingEndPoint__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__BindingEndPoint__Group_2__0();
@@ -39401,14 +39557,14 @@ 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:14087: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:14091:1: ( rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1 )
+            // InternalRoom.g:14092:2: rule__BindingEndPoint__Group_0__0__Impl rule__BindingEndPoint__Group_0__1
             {
             pushFollow(FOLLOW_73);
             rule__BindingEndPoint__Group_0__0__Impl();
@@ -39439,21 +39595,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:14099: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:14103:1: ( ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) ) )
+            // InternalRoom.g:14104: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:14104:1: ( ( rule__BindingEndPoint__ActorRefAssignment_0_0 ) )
+            // InternalRoom.g:14105: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:14106:1: ( rule__BindingEndPoint__ActorRefAssignment_0_0 )
+            // InternalRoom.g:14106:2: rule__BindingEndPoint__ActorRefAssignment_0_0
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__ActorRefAssignment_0_0();
@@ -39486,14 +39642,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:14116: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:14120:1: ( rule__BindingEndPoint__Group_0__1__Impl )
+            // InternalRoom.g:14121:2: rule__BindingEndPoint__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group_0__1__Impl();
@@ -39519,17 +39675,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:14127: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:14131:1: ( ( '.' ) )
+            // InternalRoom.g:14132:1: ( '.' )
             {
-            // InternalRoom.g:14085:1: ( '.' )
-            // InternalRoom.g:14086:1: '.'
+            // InternalRoom.g:14132:1: ( '.' )
+            // InternalRoom.g:14133:1: '.'
             {
              before(grammarAccess.getBindingEndPointAccess().getFullStopKeyword_0_1()); 
             match(input,87,FOLLOW_2); 
@@ -39556,14 +39712,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:14150: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:14154:1: ( rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1 )
+            // InternalRoom.g:14155:2: rule__BindingEndPoint__Group_2__0__Impl rule__BindingEndPoint__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__BindingEndPoint__Group_2__0__Impl();
@@ -39594,17 +39750,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:14162: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:14166:1: ( ( 'sub' ) )
+            // InternalRoom.g:14167:1: ( 'sub' )
             {
-            // InternalRoom.g:14120:1: ( 'sub' )
-            // InternalRoom.g:14121:1: 'sub'
+            // InternalRoom.g:14167:1: ( 'sub' )
+            // InternalRoom.g:14168:1: 'sub'
             {
              before(grammarAccess.getBindingEndPointAccess().getSubKeyword_2_0()); 
             match(input,88,FOLLOW_2); 
@@ -39631,14 +39787,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:14181: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:14185:1: ( rule__BindingEndPoint__Group_2__1__Impl )
+            // InternalRoom.g:14186:2: rule__BindingEndPoint__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__Group_2__1__Impl();
@@ -39664,21 +39820,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:14192: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:14196:1: ( ( ( rule__BindingEndPoint__SubAssignment_2_1 ) ) )
+            // InternalRoom.g:14197: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:14197:1: ( ( rule__BindingEndPoint__SubAssignment_2_1 ) )
+            // InternalRoom.g:14198: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:14199:1: ( rule__BindingEndPoint__SubAssignment_2_1 )
+            // InternalRoom.g:14199:2: rule__BindingEndPoint__SubAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__BindingEndPoint__SubAssignment_2_1();
@@ -39711,14 +39867,14 @@ 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:14213: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:14217:1: ( rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1 )
+            // InternalRoom.g:14218:2: rule__LayerConnection__Group__0__Impl rule__LayerConnection__Group__1
             {
             pushFollow(FOLLOW_74);
             rule__LayerConnection__Group__0__Impl();
@@ -39749,17 +39905,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:14225: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:14229:1: ( ( 'LayerConnection' ) )
+            // InternalRoom.g:14230:1: ( 'LayerConnection' )
             {
-            // InternalRoom.g:14183:1: ( 'LayerConnection' )
-            // InternalRoom.g:14184:1: 'LayerConnection'
+            // InternalRoom.g:14230:1: ( 'LayerConnection' )
+            // InternalRoom.g:14231:1: 'LayerConnection'
             {
              before(grammarAccess.getLayerConnectionAccess().getLayerConnectionKeyword_0()); 
             match(input,89,FOLLOW_2); 
@@ -39786,14 +39942,14 @@ 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:14244: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:14248:1: ( rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2 )
+            // InternalRoom.g:14249:2: rule__LayerConnection__Group__1__Impl rule__LayerConnection__Group__2
             {
             pushFollow(FOLLOW_75);
             rule__LayerConnection__Group__1__Impl();
@@ -39824,21 +39980,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:14256: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:14260:1: ( ( ( rule__LayerConnection__FromAssignment_1 ) ) )
+            // InternalRoom.g:14261:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
             {
-            // InternalRoom.g:14214:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
-            // InternalRoom.g:14215:1: ( rule__LayerConnection__FromAssignment_1 )
+            // InternalRoom.g:14261:1: ( ( rule__LayerConnection__FromAssignment_1 ) )
+            // InternalRoom.g:14262: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:14263:1: ( rule__LayerConnection__FromAssignment_1 )
+            // InternalRoom.g:14263:2: rule__LayerConnection__FromAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__FromAssignment_1();
@@ -39871,14 +40027,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:14273: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:14277:1: ( rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3 )
+            // InternalRoom.g:14278:2: rule__LayerConnection__Group__2__Impl rule__LayerConnection__Group__3
             {
             pushFollow(FOLLOW_3);
             rule__LayerConnection__Group__2__Impl();
@@ -39909,17 +40065,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:14285: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:14289:1: ( ( 'satisfied_by' ) )
+            // InternalRoom.g:14290:1: ( 'satisfied_by' )
             {
-            // InternalRoom.g:14243:1: ( 'satisfied_by' )
-            // InternalRoom.g:14244:1: 'satisfied_by'
+            // InternalRoom.g:14290:1: ( 'satisfied_by' )
+            // InternalRoom.g:14291:1: 'satisfied_by'
             {
              before(grammarAccess.getLayerConnectionAccess().getSatisfied_byKeyword_2()); 
             match(input,90,FOLLOW_2); 
@@ -39946,14 +40102,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:14304: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:14308:1: ( rule__LayerConnection__Group__3__Impl )
+            // InternalRoom.g:14309:2: rule__LayerConnection__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__Group__3__Impl();
@@ -39979,21 +40135,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:14315: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:14319:1: ( ( ( rule__LayerConnection__ToAssignment_3 ) ) )
+            // InternalRoom.g:14320:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
             {
-            // InternalRoom.g:14273:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
-            // InternalRoom.g:14274:1: ( rule__LayerConnection__ToAssignment_3 )
+            // InternalRoom.g:14320:1: ( ( rule__LayerConnection__ToAssignment_3 ) )
+            // InternalRoom.g:14321: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:14322:1: ( rule__LayerConnection__ToAssignment_3 )
+            // InternalRoom.g:14322:2: rule__LayerConnection__ToAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__LayerConnection__ToAssignment_3();
@@ -40026,14 +40182,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:14340: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:14344:1: ( rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1 )
+            // InternalRoom.g:14345:2: rule__RefSAPoint__Group__0__Impl rule__RefSAPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefSAPoint__Group__0__Impl();
@@ -40064,17 +40220,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:14352: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:14356:1: ( ( 'ref' ) )
+            // InternalRoom.g:14357:1: ( 'ref' )
             {
-            // InternalRoom.g:14310:1: ( 'ref' )
-            // InternalRoom.g:14311:1: 'ref'
+            // InternalRoom.g:14357:1: ( 'ref' )
+            // InternalRoom.g:14358:1: 'ref'
             {
              before(grammarAccess.getRefSAPointAccess().getRefKeyword_0()); 
             match(input,91,FOLLOW_2); 
@@ -40101,14 +40257,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:14371: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:14375:1: ( rule__RefSAPoint__Group__1__Impl )
+            // InternalRoom.g:14376:2: rule__RefSAPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefSAPoint__Group__1__Impl();
@@ -40134,21 +40290,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:14382: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:14386:1: ( ( ( rule__RefSAPoint__RefAssignment_1 ) ) )
+            // InternalRoom.g:14387:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
             {
-            // InternalRoom.g:14340:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
-            // InternalRoom.g:14341:1: ( rule__RefSAPoint__RefAssignment_1 )
+            // InternalRoom.g:14387:1: ( ( rule__RefSAPoint__RefAssignment_1 ) )
+            // InternalRoom.g:14388: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:14389:1: ( rule__RefSAPoint__RefAssignment_1 )
+            // InternalRoom.g:14389:2: rule__RefSAPoint__RefAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefSAPoint__RefAssignment_1();
@@ -40181,14 +40337,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:14403: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:14407:1: ( rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1 )
+            // InternalRoom.g:14408:2: rule__RelaySAPoint__Group__0__Impl rule__RelaySAPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RelaySAPoint__Group__0__Impl();
@@ -40219,17 +40375,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:14415: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:14419:1: ( ( 'relay_sap' ) )
+            // InternalRoom.g:14420:1: ( 'relay_sap' )
             {
-            // InternalRoom.g:14373:1: ( 'relay_sap' )
-            // InternalRoom.g:14374:1: 'relay_sap'
+            // InternalRoom.g:14420:1: ( 'relay_sap' )
+            // InternalRoom.g:14421:1: 'relay_sap'
             {
              before(grammarAccess.getRelaySAPointAccess().getRelay_sapKeyword_0()); 
             match(input,92,FOLLOW_2); 
@@ -40256,14 +40412,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:14434: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:14438:1: ( rule__RelaySAPoint__Group__1__Impl )
+            // InternalRoom.g:14439:2: rule__RelaySAPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RelaySAPoint__Group__1__Impl();
@@ -40289,21 +40445,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:14445: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:14449:1: ( ( ( rule__RelaySAPoint__RelayAssignment_1 ) ) )
+            // InternalRoom.g:14450:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
             {
-            // InternalRoom.g:14403:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
-            // InternalRoom.g:14404:1: ( rule__RelaySAPoint__RelayAssignment_1 )
+            // InternalRoom.g:14450:1: ( ( rule__RelaySAPoint__RelayAssignment_1 ) )
+            // InternalRoom.g:14451: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:14452:1: ( rule__RelaySAPoint__RelayAssignment_1 )
+            // InternalRoom.g:14452:2: rule__RelaySAPoint__RelayAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RelaySAPoint__RelayAssignment_1();
@@ -40336,14 +40492,14 @@ 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:14466: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:14470:1: ( rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1 )
+            // InternalRoom.g:14471:2: rule__SPPoint__Group__0__Impl rule__SPPoint__Group__1
             {
             pushFollow(FOLLOW_73);
             rule__SPPoint__Group__0__Impl();
@@ -40374,21 +40530,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:14478: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:14482:1: ( ( ( rule__SPPoint__RefAssignment_0 ) ) )
+            // InternalRoom.g:14483:1: ( ( rule__SPPoint__RefAssignment_0 ) )
             {
-            // InternalRoom.g:14436:1: ( ( rule__SPPoint__RefAssignment_0 ) )
-            // InternalRoom.g:14437:1: ( rule__SPPoint__RefAssignment_0 )
+            // InternalRoom.g:14483:1: ( ( rule__SPPoint__RefAssignment_0 ) )
+            // InternalRoom.g:14484: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:14485:1: ( rule__SPPoint__RefAssignment_0 )
+            // InternalRoom.g:14485:2: rule__SPPoint__RefAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__RefAssignment_0();
@@ -40421,14 +40577,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:14495: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:14499:1: ( rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2 )
+            // InternalRoom.g:14500:2: rule__SPPoint__Group__1__Impl rule__SPPoint__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SPPoint__Group__1__Impl();
@@ -40459,17 +40615,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__Group__1__Impl"
-    // InternalRoom.g:14460:1: rule__SPPoint__Group__1__Impl : ( '.' ) ;
+    // InternalRoom.g:14507: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:14511:1: ( ( '.' ) )
+            // InternalRoom.g:14512:1: ( '.' )
             {
-            // InternalRoom.g:14465:1: ( '.' )
-            // InternalRoom.g:14466:1: '.'
+            // InternalRoom.g:14512:1: ( '.' )
+            // InternalRoom.g:14513:1: '.'
             {
              before(grammarAccess.getSPPointAccess().getFullStopKeyword_1()); 
             match(input,87,FOLLOW_2); 
@@ -40496,14 +40652,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:14526: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:14530:1: ( rule__SPPoint__Group__2__Impl )
+            // InternalRoom.g:14531:2: rule__SPPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__Group__2__Impl();
@@ -40529,21 +40685,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:14537: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:14541:1: ( ( ( rule__SPPoint__ServiceAssignment_2 ) ) )
+            // InternalRoom.g:14542:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
             {
-            // InternalRoom.g:14495:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
-            // InternalRoom.g:14496:1: ( rule__SPPoint__ServiceAssignment_2 )
+            // InternalRoom.g:14542:1: ( ( rule__SPPoint__ServiceAssignment_2 ) )
+            // InternalRoom.g:14543: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:14544:1: ( rule__SPPoint__ServiceAssignment_2 )
+            // InternalRoom.g:14544:2: rule__SPPoint__ServiceAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SPPoint__ServiceAssignment_2();
@@ -40576,14 +40732,14 @@ 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:14560: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:14564:1: ( rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1 )
+            // InternalRoom.g:14565:2: rule__ActorRef__Group__0__Impl rule__ActorRef__Group__1
             {
             pushFollow(FOLLOW_76);
             rule__ActorRef__Group__0__Impl();
@@ -40614,29 +40770,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:14572: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:14576:1: ( ( ( rule__ActorRef__RefTypeAssignment_0 )? ) )
+            // InternalRoom.g:14577:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
             {
-            // InternalRoom.g:14530:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
-            // InternalRoom.g:14531:1: ( rule__ActorRef__RefTypeAssignment_0 )?
+            // InternalRoom.g:14577:1: ( ( rule__ActorRef__RefTypeAssignment_0 )? )
+            // InternalRoom.g:14578: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:14579:1: ( rule__ActorRef__RefTypeAssignment_0 )?
+            int alt148=2;
+            int LA148_0 = input.LA(1);
 
-            if ( ((LA147_0>=36 && LA147_0<=37)) ) {
-                alt147=1;
+            if ( ((LA148_0>=36 && LA148_0<=37)) ) {
+                alt148=1;
             }
-            switch (alt147) {
+            switch (alt148) {
                 case 1 :
-                    // InternalRoom.g:14532:2: rule__ActorRef__RefTypeAssignment_0
+                    // InternalRoom.g:14579:2: rule__ActorRef__RefTypeAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__RefTypeAssignment_0();
@@ -40672,14 +40828,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:14589: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:14593:1: ( rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2 )
+            // InternalRoom.g:14594:2: rule__ActorRef__Group__1__Impl rule__ActorRef__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__ActorRef__Group__1__Impl();
@@ -40710,17 +40866,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:14601: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:14605:1: ( ( 'ActorRef' ) )
+            // InternalRoom.g:14606:1: ( 'ActorRef' )
             {
-            // InternalRoom.g:14559:1: ( 'ActorRef' )
-            // InternalRoom.g:14560:1: 'ActorRef'
+            // InternalRoom.g:14606:1: ( 'ActorRef' )
+            // InternalRoom.g:14607:1: 'ActorRef'
             {
              before(grammarAccess.getActorRefAccess().getActorRefKeyword_1()); 
             match(input,93,FOLLOW_2); 
@@ -40747,14 +40903,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:14620: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:14624:1: ( rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3 )
+            // InternalRoom.g:14625:2: rule__ActorRef__Group__2__Impl rule__ActorRef__Group__3
             {
             pushFollow(FOLLOW_28);
             rule__ActorRef__Group__2__Impl();
@@ -40785,21 +40941,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:14632: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:14636:1: ( ( ( rule__ActorRef__NameAssignment_2 ) ) )
+            // InternalRoom.g:14637:1: ( ( rule__ActorRef__NameAssignment_2 ) )
             {
-            // InternalRoom.g:14590:1: ( ( rule__ActorRef__NameAssignment_2 ) )
-            // InternalRoom.g:14591:1: ( rule__ActorRef__NameAssignment_2 )
+            // InternalRoom.g:14637:1: ( ( rule__ActorRef__NameAssignment_2 ) )
+            // InternalRoom.g:14638: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:14639:1: ( rule__ActorRef__NameAssignment_2 )
+            // InternalRoom.g:14639:2: rule__ActorRef__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__NameAssignment_2();
@@ -40832,14 +40988,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:14649: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:14653:1: ( rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4 )
+            // InternalRoom.g:14654:2: rule__ActorRef__Group__3__Impl rule__ActorRef__Group__4
             {
             pushFollow(FOLLOW_28);
             rule__ActorRef__Group__3__Impl();
@@ -40870,29 +41026,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:14661: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:14665:1: ( ( ( rule__ActorRef__MultiplicityAssignment_3 )? ) )
+            // InternalRoom.g:14666:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
             {
-            // InternalRoom.g:14619:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
-            // InternalRoom.g:14620:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
+            // InternalRoom.g:14666:1: ( ( rule__ActorRef__MultiplicityAssignment_3 )? )
+            // InternalRoom.g:14667: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:14668:1: ( rule__ActorRef__MultiplicityAssignment_3 )?
+            int alt149=2;
+            int LA149_0 = input.LA(1);
 
-            if ( (LA148_0==62) ) {
-                alt148=1;
+            if ( (LA149_0==62) ) {
+                alt149=1;
             }
-            switch (alt148) {
+            switch (alt149) {
                 case 1 :
-                    // InternalRoom.g:14621:2: rule__ActorRef__MultiplicityAssignment_3
+                    // InternalRoom.g:14668:2: rule__ActorRef__MultiplicityAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__MultiplicityAssignment_3();
@@ -40928,14 +41084,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:14678: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:14682:1: ( rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5 )
+            // InternalRoom.g:14683:2: rule__ActorRef__Group__4__Impl rule__ActorRef__Group__5
             {
             pushFollow(FOLLOW_3);
             rule__ActorRef__Group__4__Impl();
@@ -40966,17 +41122,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__Group__4__Impl"
-    // InternalRoom.g:14643:1: rule__ActorRef__Group__4__Impl : ( ':' ) ;
+    // InternalRoom.g:14690: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:14694:1: ( ( ':' ) )
+            // InternalRoom.g:14695:1: ( ':' )
             {
-            // InternalRoom.g:14648:1: ( ':' )
-            // InternalRoom.g:14649:1: ':'
+            // InternalRoom.g:14695:1: ( ':' )
+            // InternalRoom.g:14696:1: ':'
             {
              before(grammarAccess.getActorRefAccess().getColonKeyword_4()); 
             match(input,46,FOLLOW_2); 
@@ -41003,14 +41159,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:14709: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:14713:1: ( rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6 )
+            // InternalRoom.g:14714:2: rule__ActorRef__Group__5__Impl rule__ActorRef__Group__6
             {
             pushFollow(FOLLOW_14);
             rule__ActorRef__Group__5__Impl();
@@ -41041,21 +41197,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:14721: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:14725:1: ( ( ( rule__ActorRef__TypeAssignment_5 ) ) )
+            // InternalRoom.g:14726:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
             {
-            // InternalRoom.g:14679:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
-            // InternalRoom.g:14680:1: ( rule__ActorRef__TypeAssignment_5 )
+            // InternalRoom.g:14726:1: ( ( rule__ActorRef__TypeAssignment_5 ) )
+            // InternalRoom.g:14727: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:14728:1: ( rule__ActorRef__TypeAssignment_5 )
+            // InternalRoom.g:14728:2: rule__ActorRef__TypeAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__TypeAssignment_5();
@@ -41088,14 +41244,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:14738: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:14742:1: ( rule__ActorRef__Group__6__Impl )
+            // InternalRoom.g:14743:2: rule__ActorRef__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorRef__Group__6__Impl();
@@ -41121,29 +41277,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:14749: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:14753:1: ( ( ( rule__ActorRef__DocuAssignment_6 )? ) )
+            // InternalRoom.g:14754:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:14707:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
-            // InternalRoom.g:14708:1: ( rule__ActorRef__DocuAssignment_6 )?
+            // InternalRoom.g:14754:1: ( ( rule__ActorRef__DocuAssignment_6 )? )
+            // InternalRoom.g:14755: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:14756:1: ( rule__ActorRef__DocuAssignment_6 )?
+            int alt150=2;
+            int LA150_0 = input.LA(1);
 
-            if ( (LA149_0==62) ) {
-                alt149=1;
+            if ( (LA150_0==62) ) {
+                alt150=1;
             }
-            switch (alt149) {
+            switch (alt150) {
                 case 1 :
-                    // InternalRoom.g:14709:2: rule__ActorRef__DocuAssignment_6
+                    // InternalRoom.g:14756:2: rule__ActorRef__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorRef__DocuAssignment_6();
@@ -41179,14 +41335,14 @@ 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:14780: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:14784:1: ( rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1 )
+            // InternalRoom.g:14785:2: rule__MULTIPLICITY__Group__0__Impl rule__MULTIPLICITY__Group__1
             {
             pushFollow(FOLLOW_77);
             rule__MULTIPLICITY__Group__0__Impl();
@@ -41217,17 +41373,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__0__Impl"
-    // InternalRoom.g:14745:1: rule__MULTIPLICITY__Group__0__Impl : ( '[' ) ;
+    // InternalRoom.g:14792: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:14796:1: ( ( '[' ) )
+            // InternalRoom.g:14797:1: ( '[' )
             {
-            // InternalRoom.g:14750:1: ( '[' )
-            // InternalRoom.g:14751:1: '['
+            // InternalRoom.g:14797:1: ( '[' )
+            // InternalRoom.g:14798:1: '['
             {
              before(grammarAccess.getMULTIPLICITYAccess().getLeftSquareBracketKeyword_0()); 
             match(input,62,FOLLOW_2); 
@@ -41254,14 +41410,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:14811: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:14815:1: ( rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2 )
+            // InternalRoom.g:14816:2: rule__MULTIPLICITY__Group__1__Impl rule__MULTIPLICITY__Group__2
             {
             pushFollow(FOLLOW_31);
             rule__MULTIPLICITY__Group__1__Impl();
@@ -41292,21 +41448,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:14823: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:14827:1: ( ( ( rule__MULTIPLICITY__Alternatives_1 ) ) )
+            // InternalRoom.g:14828:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
             {
-            // InternalRoom.g:14781:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
-            // InternalRoom.g:14782:1: ( rule__MULTIPLICITY__Alternatives_1 )
+            // InternalRoom.g:14828:1: ( ( rule__MULTIPLICITY__Alternatives_1 ) )
+            // InternalRoom.g:14829: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:14830:1: ( rule__MULTIPLICITY__Alternatives_1 )
+            // InternalRoom.g:14830:2: rule__MULTIPLICITY__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__MULTIPLICITY__Alternatives_1();
@@ -41339,14 +41495,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:14840: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:14844:1: ( rule__MULTIPLICITY__Group__2__Impl )
+            // InternalRoom.g:14845:2: rule__MULTIPLICITY__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__MULTIPLICITY__Group__2__Impl();
@@ -41372,17 +41528,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MULTIPLICITY__Group__2__Impl"
-    // InternalRoom.g:14804:1: rule__MULTIPLICITY__Group__2__Impl : ( ']' ) ;
+    // InternalRoom.g:14851: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:14855:1: ( ( ']' ) )
+            // InternalRoom.g:14856:1: ( ']' )
             {
-            // InternalRoom.g:14809:1: ( ']' )
-            // InternalRoom.g:14810:1: ']'
+            // InternalRoom.g:14856:1: ( ']' )
+            // InternalRoom.g:14857:1: ']'
             {
              before(grammarAccess.getMULTIPLICITYAccess().getRightSquareBracketKeyword_2()); 
             match(input,63,FOLLOW_2); 
@@ -41409,14 +41565,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:14876: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:14880:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 )
+            // InternalRoom.g:14881:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1
             {
             pushFollow(FOLLOW_40);
             rule__StateGraph__Group__0__Impl();
@@ -41447,21 +41603,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__0__Impl"
-    // InternalRoom.g:14841:1: rule__StateGraph__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:14888: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:14892:1: ( ( () ) )
+            // InternalRoom.g:14893:1: ( () )
             {
-            // InternalRoom.g:14846:1: ( () )
-            // InternalRoom.g:14847:1: ()
+            // InternalRoom.g:14893:1: ( () )
+            // InternalRoom.g:14894:1: ()
             {
              before(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); 
-            // InternalRoom.g:14848:1: ()
-            // InternalRoom.g:14850:1: 
+            // InternalRoom.g:14895:1: ()
+            // InternalRoom.g:14897:1: 
             {
             }
 
@@ -41484,14 +41640,14 @@ 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:14907: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:14911:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 )
+            // InternalRoom.g:14912:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2
             {
             pushFollow(FOLLOW_78);
             rule__StateGraph__Group__1__Impl();
@@ -41522,17 +41678,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__1__Impl"
-    // InternalRoom.g:14872:1: rule__StateGraph__Group__1__Impl : ( '{' ) ;
+    // InternalRoom.g:14919: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:14923:1: ( ( '{' ) )
+            // InternalRoom.g:14924:1: ( '{' )
             {
-            // InternalRoom.g:14877:1: ( '{' )
-            // InternalRoom.g:14878:1: '{'
+            // InternalRoom.g:14924:1: ( '{' )
+            // InternalRoom.g:14925:1: '{'
             {
              before(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); 
             match(input,44,FOLLOW_2); 
@@ -41559,14 +41715,14 @@ 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:14938: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:14942:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 )
+            // InternalRoom.g:14943:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3
             {
             pushFollow(FOLLOW_78);
             rule__StateGraph__Group__2__Impl();
@@ -41597,33 +41753,33 @@ 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:14950: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:14954:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) )
+            // InternalRoom.g:14955:1: ( ( rule__StateGraph__Alternatives_2 )* )
             {
-            // InternalRoom.g:14908:1: ( ( rule__StateGraph__Alternatives_2 )* )
-            // InternalRoom.g:14909:1: ( rule__StateGraph__Alternatives_2 )*
+            // InternalRoom.g:14955:1: ( ( rule__StateGraph__Alternatives_2 )* )
+            // InternalRoom.g:14956:1: ( rule__StateGraph__Alternatives_2 )*
             {
              before(grammarAccess.getStateGraphAccess().getAlternatives_2()); 
-            // InternalRoom.g:14910:1: ( rule__StateGraph__Alternatives_2 )*
-            loop150:
+            // InternalRoom.g:14957:1: ( rule__StateGraph__Alternatives_2 )*
+            loop151:
             do {
-                int alt150=2;
-                int LA150_0 = input.LA(1);
+                int alt151=2;
+                int LA151_0 = input.LA(1);
 
-                if ( (LA150_0==95||(LA150_0>=100 && LA150_0<=105)||LA150_0==112||LA150_0==131) ) {
-                    alt150=1;
+                if ( (LA151_0==95||(LA151_0>=100 && LA151_0<=105)||LA151_0==112||LA151_0==131) ) {
+                    alt151=1;
                 }
 
 
-                switch (alt150) {
+                switch (alt151) {
             	case 1 :
-            	    // InternalRoom.g:14910:2: rule__StateGraph__Alternatives_2
+            	    // InternalRoom.g:14957:2: rule__StateGraph__Alternatives_2
             	    {
             	    pushFollow(FOLLOW_79);
             	    rule__StateGraph__Alternatives_2();
@@ -41635,7 +41791,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop150;
+            	    break loop151;
                 }
             } while (true);
 
@@ -41662,14 +41818,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:14967: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:14971:1: ( rule__StateGraph__Group__3__Impl )
+            // InternalRoom.g:14972:2: rule__StateGraph__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateGraph__Group__3__Impl();
@@ -41695,17 +41851,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateGraph__Group__3__Impl"
-    // InternalRoom.g:14931:1: rule__StateGraph__Group__3__Impl : ( '}' ) ;
+    // InternalRoom.g:14978: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:14982:1: ( ( '}' ) )
+            // InternalRoom.g:14983:1: ( '}' )
             {
-            // InternalRoom.g:14936:1: ( '}' )
-            // InternalRoom.g:14937:1: '}'
+            // InternalRoom.g:14983:1: ( '}' )
+            // InternalRoom.g:14984:1: '}'
             {
              before(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); 
             match(input,45,FOLLOW_2); 
@@ -41732,14 +41888,14 @@ 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:15005: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:15009:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 )
+            // InternalRoom.g:15010:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1
             {
             pushFollow(FOLLOW_80);
             rule__StateMachine__Group__0__Impl();
@@ -41770,21 +41926,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__0__Impl"
-    // InternalRoom.g:14970:1: rule__StateMachine__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:15017: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:15021:1: ( ( () ) )
+            // InternalRoom.g:15022:1: ( () )
             {
-            // InternalRoom.g:14975:1: ( () )
-            // InternalRoom.g:14976:1: ()
+            // InternalRoom.g:15022:1: ( () )
+            // InternalRoom.g:15023:1: ()
             {
              before(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); 
-            // InternalRoom.g:14977:1: ()
-            // InternalRoom.g:14979:1: 
+            // InternalRoom.g:15024:1: ()
+            // InternalRoom.g:15026:1: 
             {
             }
 
@@ -41807,14 +41963,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:15036: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:15040:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 )
+            // InternalRoom.g:15041:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2
             {
             pushFollow(FOLLOW_40);
             rule__StateMachine__Group__1__Impl();
@@ -41845,17 +42001,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:15048: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:15052:1: ( ( 'StateMachine' ) )
+            // InternalRoom.g:15053:1: ( 'StateMachine' )
             {
-            // InternalRoom.g:15006:1: ( 'StateMachine' )
-            // InternalRoom.g:15007:1: 'StateMachine'
+            // InternalRoom.g:15053:1: ( 'StateMachine' )
+            // InternalRoom.g:15054:1: 'StateMachine'
             {
              before(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); 
             match(input,94,FOLLOW_2); 
@@ -41882,14 +42038,14 @@ 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:15067: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:15071:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 )
+            // InternalRoom.g:15072:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3
             {
             pushFollow(FOLLOW_78);
             rule__StateMachine__Group__2__Impl();
@@ -41920,17 +42076,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__2__Impl"
-    // InternalRoom.g:15032:1: rule__StateMachine__Group__2__Impl : ( '{' ) ;
+    // InternalRoom.g:15079: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:15083:1: ( ( '{' ) )
+            // InternalRoom.g:15084:1: ( '{' )
             {
-            // InternalRoom.g:15037:1: ( '{' )
-            // InternalRoom.g:15038:1: '{'
+            // InternalRoom.g:15084:1: ( '{' )
+            // InternalRoom.g:15085:1: '{'
             {
              before(grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2()); 
             match(input,44,FOLLOW_2); 
@@ -41957,14 +42113,14 @@ 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:15098: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:15102:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 )
+            // InternalRoom.g:15103:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4
             {
             pushFollow(FOLLOW_78);
             rule__StateMachine__Group__3__Impl();
@@ -41995,33 +42151,33 @@ 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:15110: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:15114:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) )
+            // InternalRoom.g:15115:1: ( ( rule__StateMachine__Alternatives_3 )* )
             {
-            // InternalRoom.g:15068:1: ( ( rule__StateMachine__Alternatives_3 )* )
-            // InternalRoom.g:15069:1: ( rule__StateMachine__Alternatives_3 )*
+            // InternalRoom.g:15115:1: ( ( rule__StateMachine__Alternatives_3 )* )
+            // InternalRoom.g:15116:1: ( rule__StateMachine__Alternatives_3 )*
             {
              before(grammarAccess.getStateMachineAccess().getAlternatives_3()); 
-            // InternalRoom.g:15070:1: ( rule__StateMachine__Alternatives_3 )*
-            loop151:
+            // InternalRoom.g:15117:1: ( rule__StateMachine__Alternatives_3 )*
+            loop152:
             do {
-                int alt151=2;
-                int LA151_0 = input.LA(1);
+                int alt152=2;
+                int LA152_0 = input.LA(1);
 
-                if ( (LA151_0==95||(LA151_0>=100 && LA151_0<=105)||LA151_0==112||LA151_0==131) ) {
-                    alt151=1;
+                if ( (LA152_0==95||(LA152_0>=100 && LA152_0<=105)||LA152_0==112||LA152_0==131) ) {
+                    alt152=1;
                 }
 
 
-                switch (alt151) {
+                switch (alt152) {
             	case 1 :
-            	    // InternalRoom.g:15070:2: rule__StateMachine__Alternatives_3
+            	    // InternalRoom.g:15117:2: rule__StateMachine__Alternatives_3
             	    {
             	    pushFollow(FOLLOW_79);
             	    rule__StateMachine__Alternatives_3();
@@ -42033,7 +42189,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop151;
+            	    break loop152;
                 }
             } while (true);
 
@@ -42060,14 +42216,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:15127: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:15131:1: ( rule__StateMachine__Group__4__Impl )
+            // InternalRoom.g:15132:2: rule__StateMachine__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StateMachine__Group__4__Impl();
@@ -42093,17 +42249,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateMachine__Group__4__Impl"
-    // InternalRoom.g:15091:1: rule__StateMachine__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:15138: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:15142:1: ( ( '}' ) )
+            // InternalRoom.g:15143:1: ( '}' )
             {
-            // InternalRoom.g:15096:1: ( '}' )
-            // InternalRoom.g:15097:1: '}'
+            // InternalRoom.g:15143:1: ( '}' )
+            // InternalRoom.g:15144:1: '}'
             {
              before(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -42130,14 +42286,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:15167: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:15171:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 )
+            // InternalRoom.g:15172:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__SimpleState__Group__0__Impl();
@@ -42168,17 +42324,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:15179: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:15183:1: ( ( 'State' ) )
+            // InternalRoom.g:15184:1: ( 'State' )
             {
-            // InternalRoom.g:15137:1: ( 'State' )
-            // InternalRoom.g:15138:1: 'State'
+            // InternalRoom.g:15184:1: ( 'State' )
+            // InternalRoom.g:15185:1: 'State'
             {
              before(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); 
             match(input,95,FOLLOW_2); 
@@ -42205,14 +42361,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:15198: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:15202:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 )
+            // InternalRoom.g:15203:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__SimpleState__Group__1__Impl();
@@ -42243,21 +42399,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:15210: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:15214:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) )
+            // InternalRoom.g:15215:1: ( ( rule__SimpleState__NameAssignment_1 ) )
             {
-            // InternalRoom.g:15168:1: ( ( rule__SimpleState__NameAssignment_1 ) )
-            // InternalRoom.g:15169:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalRoom.g:15215:1: ( ( rule__SimpleState__NameAssignment_1 ) )
+            // InternalRoom.g:15216: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:15217:1: ( rule__SimpleState__NameAssignment_1 )
+            // InternalRoom.g:15217:2: rule__SimpleState__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__NameAssignment_1();
@@ -42290,14 +42446,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:15227: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:15231:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 )
+            // InternalRoom.g:15232:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__SimpleState__Group__2__Impl();
@@ -42328,29 +42484,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:15239: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:15243:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) )
+            // InternalRoom.g:15244:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:15197:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
-            // InternalRoom.g:15198:1: ( rule__SimpleState__DocuAssignment_2 )?
+            // InternalRoom.g:15244:1: ( ( rule__SimpleState__DocuAssignment_2 )? )
+            // InternalRoom.g:15245: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:15246:1: ( rule__SimpleState__DocuAssignment_2 )?
+            int alt153=2;
+            int LA153_0 = input.LA(1);
 
-            if ( (LA152_0==62) ) {
-                alt152=1;
+            if ( (LA153_0==62) ) {
+                alt153=1;
             }
-            switch (alt152) {
+            switch (alt153) {
                 case 1 :
-                    // InternalRoom.g:15199:2: rule__SimpleState__DocuAssignment_2
+                    // InternalRoom.g:15246:2: rule__SimpleState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__DocuAssignment_2();
@@ -42386,14 +42542,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:15256: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:15260:1: ( rule__SimpleState__Group__3__Impl )
+            // InternalRoom.g:15261:2: rule__SimpleState__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group__3__Impl();
@@ -42419,29 +42575,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:15267: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:15271:1: ( ( ( rule__SimpleState__Group_3__0 )? ) )
+            // InternalRoom.g:15272: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:15272:1: ( ( rule__SimpleState__Group_3__0 )? )
+            // InternalRoom.g:15273: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:15274:1: ( rule__SimpleState__Group_3__0 )?
+            int alt154=2;
+            int LA154_0 = input.LA(1);
 
-            if ( (LA153_0==44) ) {
-                alt153=1;
+            if ( (LA154_0==44) ) {
+                alt154=1;
             }
-            switch (alt153) {
+            switch (alt154) {
                 case 1 :
-                    // InternalRoom.g:15227:2: rule__SimpleState__Group_3__0
+                    // InternalRoom.g:15274:2: rule__SimpleState__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3__0();
@@ -42477,14 +42633,14 @@ 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:15292: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:15296:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 )
+            // InternalRoom.g:15297:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1
             {
             pushFollow(FOLLOW_81);
             rule__SimpleState__Group_3__0__Impl();
@@ -42515,17 +42671,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:15304: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:15308:1: ( ( '{' ) )
+            // InternalRoom.g:15309:1: ( '{' )
             {
-            // InternalRoom.g:15262:1: ( '{' )
-            // InternalRoom.g:15263:1: '{'
+            // InternalRoom.g:15309:1: ( '{' )
+            // InternalRoom.g:15310:1: '{'
             {
              before(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); 
             match(input,44,FOLLOW_2); 
@@ -42552,14 +42708,14 @@ 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:15323: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:15327:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 )
+            // InternalRoom.g:15328:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2
             {
             pushFollow(FOLLOW_81);
             rule__SimpleState__Group_3__1__Impl();
@@ -42590,29 +42746,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:15335: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:15339:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) )
+            // InternalRoom.g:15340: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:15340:1: ( ( rule__SimpleState__Group_3_1__0 )? )
+            // InternalRoom.g:15341: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:15342:1: ( rule__SimpleState__Group_3_1__0 )?
+            int alt155=2;
+            int LA155_0 = input.LA(1);
 
-            if ( (LA154_0==96) ) {
-                alt154=1;
+            if ( (LA155_0==96) ) {
+                alt155=1;
             }
-            switch (alt154) {
+            switch (alt155) {
                 case 1 :
-                    // InternalRoom.g:15295:2: rule__SimpleState__Group_3_1__0
+                    // InternalRoom.g:15342:2: rule__SimpleState__Group_3_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_1__0();
@@ -42648,14 +42804,14 @@ 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:15352: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:15356:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 )
+            // InternalRoom.g:15357:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3
             {
             pushFollow(FOLLOW_81);
             rule__SimpleState__Group_3__2__Impl();
@@ -42686,29 +42842,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:15364: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:15368:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) )
+            // InternalRoom.g:15369: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:15369:1: ( ( rule__SimpleState__Group_3_2__0 )? )
+            // InternalRoom.g:15370: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:15371:1: ( rule__SimpleState__Group_3_2__0 )?
+            int alt156=2;
+            int LA156_0 = input.LA(1);
 
-            if ( (LA155_0==97) ) {
-                alt155=1;
+            if ( (LA156_0==97) ) {
+                alt156=1;
             }
-            switch (alt155) {
+            switch (alt156) {
                 case 1 :
-                    // InternalRoom.g:15324:2: rule__SimpleState__Group_3_2__0
+                    // InternalRoom.g:15371:2: rule__SimpleState__Group_3_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_2__0();
@@ -42744,14 +42900,14 @@ 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:15381: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:15385:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 )
+            // InternalRoom.g:15386:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4
             {
             pushFollow(FOLLOW_81);
             rule__SimpleState__Group_3__3__Impl();
@@ -42782,29 +42938,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:15393: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:15397:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) )
+            // InternalRoom.g:15398: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:15398:1: ( ( rule__SimpleState__Group_3_3__0 )? )
+            // InternalRoom.g:15399: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:15400:1: ( rule__SimpleState__Group_3_3__0 )?
+            int alt157=2;
+            int LA157_0 = input.LA(1);
 
-            if ( (LA156_0==98) ) {
-                alt156=1;
+            if ( (LA157_0==98) ) {
+                alt157=1;
             }
-            switch (alt156) {
+            switch (alt157) {
                 case 1 :
-                    // InternalRoom.g:15353:2: rule__SimpleState__Group_3_3__0
+                    // InternalRoom.g:15400:2: rule__SimpleState__Group_3_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_3__0();
@@ -42840,14 +42996,14 @@ 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:15410: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:15414:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 )
+            // InternalRoom.g:15415:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5
             {
             pushFollow(FOLLOW_81);
             rule__SimpleState__Group_3__4__Impl();
@@ -42878,29 +43034,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:15422: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:15426:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) )
+            // InternalRoom.g:15427: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:15427:1: ( ( rule__SimpleState__Group_3_4__0 )? )
+            // InternalRoom.g:15428: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:15429:1: ( rule__SimpleState__Group_3_4__0 )?
+            int alt158=2;
+            int LA158_0 = input.LA(1);
 
-            if ( (LA157_0==99) ) {
-                alt157=1;
+            if ( (LA158_0==99) ) {
+                alt158=1;
             }
-            switch (alt157) {
+            switch (alt158) {
                 case 1 :
-                    // InternalRoom.g:15382:2: rule__SimpleState__Group_3_4__0
+                    // InternalRoom.g:15429:2: rule__SimpleState__Group_3_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__SimpleState__Group_3_4__0();
@@ -42936,14 +43092,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:15439: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:15443:1: ( rule__SimpleState__Group_3__5__Impl )
+            // InternalRoom.g:15444:2: rule__SimpleState__Group_3__5__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3__5__Impl();
@@ -42969,17 +43125,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:15450: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:15454:1: ( ( '}' ) )
+            // InternalRoom.g:15455:1: ( '}' )
             {
-            // InternalRoom.g:15408:1: ( '}' )
-            // InternalRoom.g:15409:1: '}'
+            // InternalRoom.g:15455:1: ( '}' )
+            // InternalRoom.g:15456:1: '}'
             {
              before(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); 
             match(input,45,FOLLOW_2); 
@@ -43006,14 +43162,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:15481: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:15485:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 )
+            // InternalRoom.g:15486: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 +43200,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:15493: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:15497:1: ( ( 'entry' ) )
+            // InternalRoom.g:15498:1: ( 'entry' )
             {
-            // InternalRoom.g:15451:1: ( 'entry' )
-            // InternalRoom.g:15452:1: 'entry'
+            // InternalRoom.g:15498:1: ( 'entry' )
+            // InternalRoom.g:15499:1: 'entry'
             {
              before(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); 
             match(input,96,FOLLOW_2); 
@@ -43081,14 +43237,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:15512: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:15516:1: ( rule__SimpleState__Group_3_1__1__Impl )
+            // InternalRoom.g:15517:2: rule__SimpleState__Group_3_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_1__1__Impl();
@@ -43114,21 +43270,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:15523: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:15527:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) )
+            // InternalRoom.g:15528: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:15528:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) )
+            // InternalRoom.g:15529: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:15530:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 )
+            // InternalRoom.g:15530:2: rule__SimpleState__EntryCodeAssignment_3_1_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__EntryCodeAssignment_3_1_1();
@@ -43161,14 +43317,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:15544: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:15548:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 )
+            // InternalRoom.g:15549: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 +43355,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:15556: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:15560:1: ( ( 'exit' ) )
+            // InternalRoom.g:15561:1: ( 'exit' )
             {
-            // InternalRoom.g:15514:1: ( 'exit' )
-            // InternalRoom.g:15515:1: 'exit'
+            // InternalRoom.g:15561:1: ( 'exit' )
+            // InternalRoom.g:15562:1: 'exit'
             {
              before(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); 
             match(input,97,FOLLOW_2); 
@@ -43236,14 +43392,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:15575: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:15579:1: ( rule__SimpleState__Group_3_2__1__Impl )
+            // InternalRoom.g:15580:2: rule__SimpleState__Group_3_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_2__1__Impl();
@@ -43269,21 +43425,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:15586: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:15590:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) )
+            // InternalRoom.g:15591: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:15591:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) )
+            // InternalRoom.g:15592: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:15593:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 )
+            // InternalRoom.g:15593:2: rule__SimpleState__ExitCodeAssignment_3_2_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__ExitCodeAssignment_3_2_1();
@@ -43316,14 +43472,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:15607: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:15611:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 )
+            // InternalRoom.g:15612: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 +43510,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:15619: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:15623:1: ( ( 'do' ) )
+            // InternalRoom.g:15624:1: ( 'do' )
             {
-            // InternalRoom.g:15577:1: ( 'do' )
-            // InternalRoom.g:15578:1: 'do'
+            // InternalRoom.g:15624:1: ( 'do' )
+            // InternalRoom.g:15625:1: 'do'
             {
              before(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); 
             match(input,98,FOLLOW_2); 
@@ -43391,14 +43547,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:15638: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:15642:1: ( rule__SimpleState__Group_3_3__1__Impl )
+            // InternalRoom.g:15643:2: rule__SimpleState__Group_3_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_3__1__Impl();
@@ -43424,21 +43580,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:15649: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:15653:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) )
+            // InternalRoom.g:15654: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:15654:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) )
+            // InternalRoom.g:15655: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:15656:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 )
+            // InternalRoom.g:15656:2: rule__SimpleState__DoCodeAssignment_3_3_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__DoCodeAssignment_3_3_1();
@@ -43471,14 +43627,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:15670: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:15674:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 )
+            // InternalRoom.g:15675: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 +43665,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:15682: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:15686:1: ( ( 'subgraph' ) )
+            // InternalRoom.g:15687:1: ( 'subgraph' )
             {
-            // InternalRoom.g:15640:1: ( 'subgraph' )
-            // InternalRoom.g:15641:1: 'subgraph'
+            // InternalRoom.g:15687:1: ( 'subgraph' )
+            // InternalRoom.g:15688:1: 'subgraph'
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); 
             match(input,99,FOLLOW_2); 
@@ -43546,14 +43702,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:15701: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:15705:1: ( rule__SimpleState__Group_3_4__1__Impl )
+            // InternalRoom.g:15706:2: rule__SimpleState__Group_3_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__Group_3_4__1__Impl();
@@ -43579,21 +43735,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:15712: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:15716:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) )
+            // InternalRoom.g:15717: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:15717:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) )
+            // InternalRoom.g:15718: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:15719:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 )
+            // InternalRoom.g:15719:2: rule__SimpleState__SubgraphAssignment_3_4_1
             {
             pushFollow(FOLLOW_2);
             rule__SimpleState__SubgraphAssignment_3_4_1();
@@ -43626,14 +43782,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:15733: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:15737:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 )
+            // InternalRoom.g:15738:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefinedState__Group__0__Impl();
@@ -43664,17 +43820,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:15745: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:15749:1: ( ( 'RefinedState' ) )
+            // InternalRoom.g:15750:1: ( 'RefinedState' )
             {
-            // InternalRoom.g:15703:1: ( 'RefinedState' )
-            // InternalRoom.g:15704:1: 'RefinedState'
+            // InternalRoom.g:15750:1: ( 'RefinedState' )
+            // InternalRoom.g:15751:1: 'RefinedState'
             {
              before(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); 
             match(input,100,FOLLOW_2); 
@@ -43701,14 +43857,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:15764: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:15768:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 )
+            // InternalRoom.g:15769:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RefinedState__Group__1__Impl();
@@ -43739,21 +43895,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:15776: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:15780:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) )
+            // InternalRoom.g:15781:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
             {
-            // InternalRoom.g:15734:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
-            // InternalRoom.g:15735:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalRoom.g:15781:1: ( ( rule__RefinedState__TargetAssignment_1 ) )
+            // InternalRoom.g:15782: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:15783:1: ( rule__RefinedState__TargetAssignment_1 )
+            // InternalRoom.g:15783:2: rule__RefinedState__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__TargetAssignment_1();
@@ -43786,14 +43942,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:15793: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:15797:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 )
+            // InternalRoom.g:15798:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RefinedState__Group__2__Impl();
@@ -43824,29 +43980,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:15805: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:15809:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) )
+            // InternalRoom.g:15810:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:15763:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
-            // InternalRoom.g:15764:1: ( rule__RefinedState__DocuAssignment_2 )?
+            // InternalRoom.g:15810:1: ( ( rule__RefinedState__DocuAssignment_2 )? )
+            // InternalRoom.g:15811: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:15812:1: ( rule__RefinedState__DocuAssignment_2 )?
+            int alt159=2;
+            int LA159_0 = input.LA(1);
 
-            if ( (LA158_0==62) ) {
-                alt158=1;
+            if ( (LA159_0==62) ) {
+                alt159=1;
             }
-            switch (alt158) {
+            switch (alt159) {
                 case 1 :
-                    // InternalRoom.g:15765:2: rule__RefinedState__DocuAssignment_2
+                    // InternalRoom.g:15812:2: rule__RefinedState__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__DocuAssignment_2();
@@ -43882,14 +44038,14 @@ 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:15822: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:15826:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 )
+            // InternalRoom.g:15827:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4
             {
             pushFollow(FOLLOW_81);
             rule__RefinedState__Group__3__Impl();
@@ -43920,17 +44076,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__3__Impl"
-    // InternalRoom.g:15787:1: rule__RefinedState__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:15834: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:15838:1: ( ( '{' ) )
+            // InternalRoom.g:15839:1: ( '{' )
             {
-            // InternalRoom.g:15792:1: ( '{' )
-            // InternalRoom.g:15793:1: '{'
+            // InternalRoom.g:15839:1: ( '{' )
+            // InternalRoom.g:15840:1: '{'
             {
              before(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -43957,14 +44113,14 @@ 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:15853: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:15857:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 )
+            // InternalRoom.g:15858:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5
             {
             pushFollow(FOLLOW_81);
             rule__RefinedState__Group__4__Impl();
@@ -43995,29 +44151,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:15865: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:15869:1: ( ( ( rule__RefinedState__Group_4__0 )? ) )
+            // InternalRoom.g:15870: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:15870:1: ( ( rule__RefinedState__Group_4__0 )? )
+            // InternalRoom.g:15871: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:15872:1: ( rule__RefinedState__Group_4__0 )?
+            int alt160=2;
+            int LA160_0 = input.LA(1);
 
-            if ( (LA159_0==96) ) {
-                alt159=1;
+            if ( (LA160_0==96) ) {
+                alt160=1;
             }
-            switch (alt159) {
+            switch (alt160) {
                 case 1 :
-                    // InternalRoom.g:15825:2: rule__RefinedState__Group_4__0
+                    // InternalRoom.g:15872:2: rule__RefinedState__Group_4__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_4__0();
@@ -44053,14 +44209,14 @@ 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:15882: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:15886:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 )
+            // InternalRoom.g:15887:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6
             {
             pushFollow(FOLLOW_81);
             rule__RefinedState__Group__5__Impl();
@@ -44091,29 +44247,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:15894: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:15898:1: ( ( ( rule__RefinedState__Group_5__0 )? ) )
+            // InternalRoom.g:15899: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:15899:1: ( ( rule__RefinedState__Group_5__0 )? )
+            // InternalRoom.g:15900: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:15901:1: ( rule__RefinedState__Group_5__0 )?
+            int alt161=2;
+            int LA161_0 = input.LA(1);
 
-            if ( (LA160_0==97) ) {
-                alt160=1;
+            if ( (LA161_0==97) ) {
+                alt161=1;
             }
-            switch (alt160) {
+            switch (alt161) {
                 case 1 :
-                    // InternalRoom.g:15854:2: rule__RefinedState__Group_5__0
+                    // InternalRoom.g:15901:2: rule__RefinedState__Group_5__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_5__0();
@@ -44149,14 +44305,14 @@ 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:15911: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:15915:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 )
+            // InternalRoom.g:15916:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7
             {
             pushFollow(FOLLOW_81);
             rule__RefinedState__Group__6__Impl();
@@ -44187,29 +44343,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:15923: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:15927:1: ( ( ( rule__RefinedState__Group_6__0 )? ) )
+            // InternalRoom.g:15928: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:15928:1: ( ( rule__RefinedState__Group_6__0 )? )
+            // InternalRoom.g:15929: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:15930:1: ( rule__RefinedState__Group_6__0 )?
+            int alt162=2;
+            int LA162_0 = input.LA(1);
 
-            if ( (LA161_0==98) ) {
-                alt161=1;
+            if ( (LA162_0==98) ) {
+                alt162=1;
             }
-            switch (alt161) {
+            switch (alt162) {
                 case 1 :
-                    // InternalRoom.g:15883:2: rule__RefinedState__Group_6__0
+                    // InternalRoom.g:15930:2: rule__RefinedState__Group_6__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_6__0();
@@ -44245,14 +44401,14 @@ 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:15940: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:15944:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 )
+            // InternalRoom.g:15945:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8
             {
             pushFollow(FOLLOW_81);
             rule__RefinedState__Group__7__Impl();
@@ -44283,29 +44439,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:15952: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:15956:1: ( ( ( rule__RefinedState__Group_7__0 )? ) )
+            // InternalRoom.g:15957: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:15957:1: ( ( rule__RefinedState__Group_7__0 )? )
+            // InternalRoom.g:15958: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:15959:1: ( rule__RefinedState__Group_7__0 )?
+            int alt163=2;
+            int LA163_0 = input.LA(1);
 
-            if ( (LA162_0==99) ) {
-                alt162=1;
+            if ( (LA163_0==99) ) {
+                alt163=1;
             }
-            switch (alt162) {
+            switch (alt163) {
                 case 1 :
-                    // InternalRoom.g:15912:2: rule__RefinedState__Group_7__0
+                    // InternalRoom.g:15959:2: rule__RefinedState__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedState__Group_7__0();
@@ -44341,14 +44497,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:15969: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:15973:1: ( rule__RefinedState__Group__8__Impl )
+            // InternalRoom.g:15974:2: rule__RefinedState__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group__8__Impl();
@@ -44374,17 +44530,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__Group__8__Impl"
-    // InternalRoom.g:15933:1: rule__RefinedState__Group__8__Impl : ( '}' ) ;
+    // InternalRoom.g:15980: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:15984:1: ( ( '}' ) )
+            // InternalRoom.g:15985:1: ( '}' )
             {
-            // InternalRoom.g:15938:1: ( '}' )
-            // InternalRoom.g:15939:1: '}'
+            // InternalRoom.g:15985:1: ( '}' )
+            // InternalRoom.g:15986:1: '}'
             {
              before(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); 
             match(input,45,FOLLOW_2); 
@@ -44411,14 +44567,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:16017: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:16021:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 )
+            // InternalRoom.g:16022:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_4__0__Impl();
@@ -44449,17 +44605,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:16029: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:16033:1: ( ( 'entry' ) )
+            // InternalRoom.g:16034:1: ( 'entry' )
             {
-            // InternalRoom.g:15987:1: ( 'entry' )
-            // InternalRoom.g:15988:1: 'entry'
+            // InternalRoom.g:16034:1: ( 'entry' )
+            // InternalRoom.g:16035:1: 'entry'
             {
              before(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); 
             match(input,96,FOLLOW_2); 
@@ -44486,14 +44642,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:16048: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:16052:1: ( rule__RefinedState__Group_4__1__Impl )
+            // InternalRoom.g:16053:2: rule__RefinedState__Group_4__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_4__1__Impl();
@@ -44519,21 +44675,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:16059: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:16063:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) )
+            // InternalRoom.g:16064: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:16064:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) )
+            // InternalRoom.g:16065: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:16066:1: ( rule__RefinedState__EntryCodeAssignment_4_1 )
+            // InternalRoom.g:16066:2: rule__RefinedState__EntryCodeAssignment_4_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__EntryCodeAssignment_4_1();
@@ -44566,14 +44722,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:16080: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:16084:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 )
+            // InternalRoom.g:16085:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_5__0__Impl();
@@ -44604,17 +44760,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:16092: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:16096:1: ( ( 'exit' ) )
+            // InternalRoom.g:16097:1: ( 'exit' )
             {
-            // InternalRoom.g:16050:1: ( 'exit' )
-            // InternalRoom.g:16051:1: 'exit'
+            // InternalRoom.g:16097:1: ( 'exit' )
+            // InternalRoom.g:16098:1: 'exit'
             {
              before(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); 
             match(input,97,FOLLOW_2); 
@@ -44641,14 +44797,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:16111: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:16115:1: ( rule__RefinedState__Group_5__1__Impl )
+            // InternalRoom.g:16116:2: rule__RefinedState__Group_5__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_5__1__Impl();
@@ -44674,21 +44830,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:16122: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:16126:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) )
+            // InternalRoom.g:16127: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:16127:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) )
+            // InternalRoom.g:16128: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:16129:1: ( rule__RefinedState__ExitCodeAssignment_5_1 )
+            // InternalRoom.g:16129:2: rule__RefinedState__ExitCodeAssignment_5_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__ExitCodeAssignment_5_1();
@@ -44721,14 +44877,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:16143: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:16147:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 )
+            // InternalRoom.g:16148:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1
             {
             pushFollow(FOLLOW_27);
             rule__RefinedState__Group_6__0__Impl();
@@ -44759,17 +44915,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:16155: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:16159:1: ( ( 'do' ) )
+            // InternalRoom.g:16160:1: ( 'do' )
             {
-            // InternalRoom.g:16113:1: ( 'do' )
-            // InternalRoom.g:16114:1: 'do'
+            // InternalRoom.g:16160:1: ( 'do' )
+            // InternalRoom.g:16161:1: 'do'
             {
              before(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); 
             match(input,98,FOLLOW_2); 
@@ -44796,14 +44952,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:16174: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:16178:1: ( rule__RefinedState__Group_6__1__Impl )
+            // InternalRoom.g:16179:2: rule__RefinedState__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_6__1__Impl();
@@ -44829,21 +44985,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:16185: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:16189:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) )
+            // InternalRoom.g:16190: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:16190:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) )
+            // InternalRoom.g:16191: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:16192:1: ( rule__RefinedState__DoCodeAssignment_6_1 )
+            // InternalRoom.g:16192:2: rule__RefinedState__DoCodeAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__DoCodeAssignment_6_1();
@@ -44876,14 +45032,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:16206: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:16210:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 )
+            // InternalRoom.g:16211:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1
             {
             pushFollow(FOLLOW_40);
             rule__RefinedState__Group_7__0__Impl();
@@ -44914,17 +45070,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:16218: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:16222:1: ( ( 'subgraph' ) )
+            // InternalRoom.g:16223:1: ( 'subgraph' )
             {
-            // InternalRoom.g:16176:1: ( 'subgraph' )
-            // InternalRoom.g:16177:1: 'subgraph'
+            // InternalRoom.g:16223:1: ( 'subgraph' )
+            // InternalRoom.g:16224:1: 'subgraph'
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); 
             match(input,99,FOLLOW_2); 
@@ -44951,14 +45107,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:16237: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:16241:1: ( rule__RefinedState__Group_7__1__Impl )
+            // InternalRoom.g:16242:2: rule__RefinedState__Group_7__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__Group_7__1__Impl();
@@ -44984,21 +45140,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:16248: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:16252:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) )
+            // InternalRoom.g:16253: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:16253:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) )
+            // InternalRoom.g:16254: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:16255:1: ( rule__RefinedState__SubgraphAssignment_7_1 )
+            // InternalRoom.g:16255:2: rule__RefinedState__SubgraphAssignment_7_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedState__SubgraphAssignment_7_1();
@@ -45031,14 +45187,14 @@ 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:16269: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:16273:1: ( rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1 )
+            // InternalRoom.g:16274:2: rule__DetailCode__Group_0__0__Impl rule__DetailCode__Group_0__1
             {
             pushFollow(FOLLOW_82);
             rule__DetailCode__Group_0__0__Impl();
@@ -45069,21 +45225,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:16281: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:16285:1: ( ( () ) )
+            // InternalRoom.g:16286:1: ( () )
             {
-            // InternalRoom.g:16239:1: ( () )
-            // InternalRoom.g:16240:1: ()
+            // InternalRoom.g:16286:1: ( () )
+            // InternalRoom.g:16287:1: ()
             {
              before(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0_0()); 
-            // InternalRoom.g:16241:1: ()
-            // InternalRoom.g:16243:1: 
+            // InternalRoom.g:16288:1: ()
+            // InternalRoom.g:16290:1: 
             {
             }
 
@@ -45106,14 +45262,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:16300: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:16304:1: ( rule__DetailCode__Group_0__1__Impl )
+            // InternalRoom.g:16305:2: rule__DetailCode__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_0__1__Impl();
@@ -45139,29 +45295,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:16311: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:16315:1: ( ( ( rule__DetailCode__LinesAssignment_0_1 )? ) )
+            // InternalRoom.g:16316: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:16316:1: ( ( rule__DetailCode__LinesAssignment_0_1 )? )
+            // InternalRoom.g:16317: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:16318:1: ( rule__DetailCode__LinesAssignment_0_1 )?
+            int alt164=2;
+            int LA164_0 = input.LA(1);
 
-            if ( (LA163_0==RULE_CC_STRING) ) {
-                alt163=1;
+            if ( (LA164_0==RULE_CC_STRING) ) {
+                alt164=1;
             }
-            switch (alt163) {
+            switch (alt164) {
                 case 1 :
-                    // InternalRoom.g:16271:2: rule__DetailCode__LinesAssignment_0_1
+                    // InternalRoom.g:16318:2: rule__DetailCode__LinesAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__DetailCode__LinesAssignment_0_1();
@@ -45197,14 +45353,14 @@ 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:16332: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:16336:1: ( rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1 )
+            // InternalRoom.g:16337:2: rule__DetailCode__Group_1__0__Impl rule__DetailCode__Group_1__1
             {
             pushFollow(FOLLOW_83);
             rule__DetailCode__Group_1__0__Impl();
@@ -45235,21 +45391,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:16344: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:16348:1: ( ( ( rule__DetailCode__UsedAssignment_1_0 ) ) )
+            // InternalRoom.g:16349: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:16349:1: ( ( rule__DetailCode__UsedAssignment_1_0 ) )
+            // InternalRoom.g:16350: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:16351:1: ( rule__DetailCode__UsedAssignment_1_0 )
+            // InternalRoom.g:16351:2: rule__DetailCode__UsedAssignment_1_0
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__UsedAssignment_1_0();
@@ -45282,14 +45438,14 @@ 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:16361: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:16365:1: ( rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2 )
+            // InternalRoom.g:16366:2: rule__DetailCode__Group_1__1__Impl rule__DetailCode__Group_1__2
             {
             pushFollow(FOLLOW_83);
             rule__DetailCode__Group_1__1__Impl();
@@ -45320,33 +45476,33 @@ 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:16373: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:16377:1: ( ( ( rule__DetailCode__LinesAssignment_1_1 )* ) )
+            // InternalRoom.g:16378: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:16378:1: ( ( rule__DetailCode__LinesAssignment_1_1 )* )
+            // InternalRoom.g:16379:1: ( rule__DetailCode__LinesAssignment_1_1 )*
             {
              before(grammarAccess.getDetailCodeAccess().getLinesAssignment_1_1()); 
-            // InternalRoom.g:16333:1: ( rule__DetailCode__LinesAssignment_1_1 )*
-            loop164:
+            // InternalRoom.g:16380:1: ( rule__DetailCode__LinesAssignment_1_1 )*
+            loop165:
             do {
-                int alt164=2;
-                int LA164_0 = input.LA(1);
+                int alt165=2;
+                int LA165_0 = input.LA(1);
 
-                if ( (LA164_0==RULE_STRING) ) {
-                    alt164=1;
+                if ( (LA165_0==RULE_STRING) ) {
+                    alt165=1;
                 }
 
 
-                switch (alt164) {
+                switch (alt165) {
             	case 1 :
-            	    // InternalRoom.g:16333:2: rule__DetailCode__LinesAssignment_1_1
+            	    // InternalRoom.g:16380:2: rule__DetailCode__LinesAssignment_1_1
             	    {
             	    pushFollow(FOLLOW_84);
             	    rule__DetailCode__LinesAssignment_1_1();
@@ -45358,7 +45514,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop164;
+            	    break loop165;
                 }
             } while (true);
 
@@ -45385,14 +45541,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:16390: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:16394:1: ( rule__DetailCode__Group_1__2__Impl )
+            // InternalRoom.g:16395:2: rule__DetailCode__Group_1__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DetailCode__Group_1__2__Impl();
@@ -45418,17 +45574,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:16401: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:16405:1: ( ( '}' ) )
+            // InternalRoom.g:16406:1: ( '}' )
             {
-            // InternalRoom.g:16359:1: ( '}' )
-            // InternalRoom.g:16360:1: '}'
+            // InternalRoom.g:16406:1: ( '}' )
+            // InternalRoom.g:16407:1: '}'
             {
              before(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_1_2()); 
             match(input,45,FOLLOW_2); 
@@ -45455,14 +45611,14 @@ 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:16426: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:16430:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 )
+            // InternalRoom.g:16431:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1
             {
             pushFollow(FOLLOW_85);
             rule__TransitionPoint__Group__0__Impl();
@@ -45493,29 +45649,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:16438: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:16442:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) )
+            // InternalRoom.g:16443:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
             {
-            // InternalRoom.g:16396:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
-            // InternalRoom.g:16397:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            // InternalRoom.g:16443:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? )
+            // InternalRoom.g:16444: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:16445:1: ( rule__TransitionPoint__HandlerAssignment_0 )?
+            int alt166=2;
+            int LA166_0 = input.LA(1);
 
-            if ( (LA165_0==131) ) {
-                alt165=1;
+            if ( (LA166_0==131) ) {
+                alt166=1;
             }
-            switch (alt165) {
+            switch (alt166) {
                 case 1 :
-                    // InternalRoom.g:16398:2: rule__TransitionPoint__HandlerAssignment_0
+                    // InternalRoom.g:16445:2: rule__TransitionPoint__HandlerAssignment_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TransitionPoint__HandlerAssignment_0();
@@ -45551,14 +45707,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:16455: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:16459:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 )
+            // InternalRoom.g:16460:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__TransitionPoint__Group__1__Impl();
@@ -45589,17 +45745,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:16467: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:16471:1: ( ( 'TransitionPoint' ) )
+            // InternalRoom.g:16472:1: ( 'TransitionPoint' )
             {
-            // InternalRoom.g:16425:1: ( 'TransitionPoint' )
-            // InternalRoom.g:16426:1: 'TransitionPoint'
+            // InternalRoom.g:16472:1: ( 'TransitionPoint' )
+            // InternalRoom.g:16473:1: 'TransitionPoint'
             {
              before(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); 
             match(input,101,FOLLOW_2); 
@@ -45626,14 +45782,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:16486: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:16490:1: ( rule__TransitionPoint__Group__2__Impl )
+            // InternalRoom.g:16491:2: rule__TransitionPoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__Group__2__Impl();
@@ -45659,21 +45815,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:16497: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:16501:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) )
+            // InternalRoom.g:16502:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
             {
-            // InternalRoom.g:16455:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
-            // InternalRoom.g:16456:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalRoom.g:16502:1: ( ( rule__TransitionPoint__NameAssignment_2 ) )
+            // InternalRoom.g:16503: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:16504:1: ( rule__TransitionPoint__NameAssignment_2 )
+            // InternalRoom.g:16504:2: rule__TransitionPoint__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__TransitionPoint__NameAssignment_2();
@@ -45706,14 +45862,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:16520: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:16524:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 )
+            // InternalRoom.g:16525:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__EntryPoint__Group__0__Impl();
@@ -45744,17 +45900,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:16532: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:16536:1: ( ( 'EntryPoint' ) )
+            // InternalRoom.g:16537:1: ( 'EntryPoint' )
             {
-            // InternalRoom.g:16490:1: ( 'EntryPoint' )
-            // InternalRoom.g:16491:1: 'EntryPoint'
+            // InternalRoom.g:16537:1: ( 'EntryPoint' )
+            // InternalRoom.g:16538:1: 'EntryPoint'
             {
              before(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); 
             match(input,102,FOLLOW_2); 
@@ -45781,14 +45937,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:16551: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:16555:1: ( rule__EntryPoint__Group__1__Impl )
+            // InternalRoom.g:16556:2: rule__EntryPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__Group__1__Impl();
@@ -45814,21 +45970,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:16562: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:16566:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16567:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16520:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
-            // InternalRoom.g:16521:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalRoom.g:16567:1: ( ( rule__EntryPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16568: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:16569:1: ( rule__EntryPoint__NameAssignment_1 )
+            // InternalRoom.g:16569:2: rule__EntryPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__EntryPoint__NameAssignment_1();
@@ -45861,14 +46017,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:16583: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:16587:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 )
+            // InternalRoom.g:16588:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ExitPoint__Group__0__Impl();
@@ -45899,17 +46055,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:16595: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:16599:1: ( ( 'ExitPoint' ) )
+            // InternalRoom.g:16600:1: ( 'ExitPoint' )
             {
-            // InternalRoom.g:16553:1: ( 'ExitPoint' )
-            // InternalRoom.g:16554:1: 'ExitPoint'
+            // InternalRoom.g:16600:1: ( 'ExitPoint' )
+            // InternalRoom.g:16601:1: 'ExitPoint'
             {
              before(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); 
             match(input,103,FOLLOW_2); 
@@ -45936,14 +46092,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:16614: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:16618:1: ( rule__ExitPoint__Group__1__Impl )
+            // InternalRoom.g:16619:2: rule__ExitPoint__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__Group__1__Impl();
@@ -45969,21 +46125,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:16625: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:16629:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16630:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16583:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
-            // InternalRoom.g:16584:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalRoom.g:16630:1: ( ( rule__ExitPoint__NameAssignment_1 ) )
+            // InternalRoom.g:16631: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:16632:1: ( rule__ExitPoint__NameAssignment_1 )
+            // InternalRoom.g:16632:2: rule__ExitPoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ExitPoint__NameAssignment_1();
@@ -46016,14 +46172,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:16646: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:16650:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 )
+            // InternalRoom.g:16651:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ChoicePoint__Group__0__Impl();
@@ -46054,17 +46210,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:16658: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:16662:1: ( ( 'ChoicePoint' ) )
+            // InternalRoom.g:16663:1: ( 'ChoicePoint' )
             {
-            // InternalRoom.g:16616:1: ( 'ChoicePoint' )
-            // InternalRoom.g:16617:1: 'ChoicePoint'
+            // InternalRoom.g:16663:1: ( 'ChoicePoint' )
+            // InternalRoom.g:16664:1: 'ChoicePoint'
             {
              before(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); 
             match(input,104,FOLLOW_2); 
@@ -46091,14 +46247,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:16677: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:16681:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 )
+            // InternalRoom.g:16682:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2
             {
             pushFollow(FOLLOW_14);
             rule__ChoicePoint__Group__1__Impl();
@@ -46129,21 +46285,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:16689: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:16693:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) )
+            // InternalRoom.g:16694:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
             {
-            // InternalRoom.g:16647:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
-            // InternalRoom.g:16648:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalRoom.g:16694:1: ( ( rule__ChoicePoint__NameAssignment_1 ) )
+            // InternalRoom.g:16695: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:16696:1: ( rule__ChoicePoint__NameAssignment_1 )
+            // InternalRoom.g:16696:2: rule__ChoicePoint__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__NameAssignment_1();
@@ -46176,14 +46332,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:16706: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:16710:1: ( rule__ChoicePoint__Group__2__Impl )
+            // InternalRoom.g:16711:2: rule__ChoicePoint__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicePoint__Group__2__Impl();
@@ -46209,29 +46365,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:16717: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:16721:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) )
+            // InternalRoom.g:16722:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:16675:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
-            // InternalRoom.g:16676:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            // InternalRoom.g:16722:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? )
+            // InternalRoom.g:16723: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:16724:1: ( rule__ChoicePoint__DocuAssignment_2 )?
+            int alt167=2;
+            int LA167_0 = input.LA(1);
 
-            if ( (LA166_0==62) ) {
-                alt166=1;
+            if ( (LA167_0==62) ) {
+                alt167=1;
             }
-            switch (alt166) {
+            switch (alt167) {
                 case 1 :
-                    // InternalRoom.g:16677:2: rule__ChoicePoint__DocuAssignment_2
+                    // InternalRoom.g:16724:2: rule__ChoicePoint__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__ChoicePoint__DocuAssignment_2();
@@ -46267,14 +46423,14 @@ 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:16740: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:16744:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 )
+            // InternalRoom.g:16745:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1
             {
             pushFollow(FOLLOW_86);
             rule__InitialTransition__Group__0__Impl();
@@ -46305,17 +46461,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:16752: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:16756:1: ( ( 'Transition' ) )
+            // InternalRoom.g:16757:1: ( 'Transition' )
             {
-            // InternalRoom.g:16710:1: ( 'Transition' )
-            // InternalRoom.g:16711:1: 'Transition'
+            // InternalRoom.g:16757:1: ( 'Transition' )
+            // InternalRoom.g:16758:1: 'Transition'
             {
              before(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -46342,14 +46498,14 @@ 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:16771: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:16775:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 )
+            // InternalRoom.g:16776:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2
             {
             pushFollow(FOLLOW_86);
             rule__InitialTransition__Group__1__Impl();
@@ -46380,29 +46536,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:16783: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:16787:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:16788:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:16741:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
-            // InternalRoom.g:16742:1: ( rule__InitialTransition__NameAssignment_1 )?
+            // InternalRoom.g:16788:1: ( ( rule__InitialTransition__NameAssignment_1 )? )
+            // InternalRoom.g:16789: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:16790:1: ( rule__InitialTransition__NameAssignment_1 )?
+            int alt168=2;
+            int LA168_0 = input.LA(1);
 
-            if ( (LA167_0==RULE_ID) ) {
-                alt167=1;
+            if ( (LA168_0==RULE_ID) ) {
+                alt168=1;
             }
-            switch (alt167) {
+            switch (alt168) {
                 case 1 :
-                    // InternalRoom.g:16743:2: rule__InitialTransition__NameAssignment_1
+                    // InternalRoom.g:16790:2: rule__InitialTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__NameAssignment_1();
@@ -46438,14 +46594,14 @@ 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:16800: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:16804:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 )
+            // InternalRoom.g:16805:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3
             {
             pushFollow(FOLLOW_87);
             rule__InitialTransition__Group__2__Impl();
@@ -46476,17 +46632,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__2__Impl"
-    // InternalRoom.g:16765:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:16812: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:16816:1: ( ( ':' ) )
+            // InternalRoom.g:16817:1: ( ':' )
             {
-            // InternalRoom.g:16770:1: ( ':' )
-            // InternalRoom.g:16771:1: ':'
+            // InternalRoom.g:16817:1: ( ':' )
+            // InternalRoom.g:16818:1: ':'
             {
              before(grammarAccess.getInitialTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -46513,14 +46669,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:16831: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:16835:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 )
+            // InternalRoom.g:16836:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__InitialTransition__Group__3__Impl();
@@ -46551,17 +46707,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:16843: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:16847:1: ( ( 'initial' ) )
+            // InternalRoom.g:16848:1: ( 'initial' )
             {
-            // InternalRoom.g:16801:1: ( 'initial' )
-            // InternalRoom.g:16802:1: 'initial'
+            // InternalRoom.g:16848:1: ( 'initial' )
+            // InternalRoom.g:16849:1: 'initial'
             {
              before(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); 
             match(input,106,FOLLOW_2); 
@@ -46588,14 +46744,14 @@ 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:16862: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:16866:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 )
+            // InternalRoom.g:16867:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5
             {
             pushFollow(FOLLOW_88);
             rule__InitialTransition__Group__4__Impl();
@@ -46626,17 +46782,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__Group__4__Impl"
-    // InternalRoom.g:16827:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:16874: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:16878:1: ( ( '->' ) )
+            // InternalRoom.g:16879:1: ( '->' )
             {
-            // InternalRoom.g:16832:1: ( '->' )
-            // InternalRoom.g:16833:1: '->'
+            // InternalRoom.g:16879:1: ( '->' )
+            // InternalRoom.g:16880:1: '->'
             {
              before(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -46663,14 +46819,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:16893: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:16897:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 )
+            // InternalRoom.g:16898:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__InitialTransition__Group__5__Impl();
@@ -46701,21 +46857,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:16905: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:16909:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:16910:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:16863:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
-            // InternalRoom.g:16864:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalRoom.g:16910:1: ( ( rule__InitialTransition__ToAssignment_5 ) )
+            // InternalRoom.g:16911: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:16912:1: ( rule__InitialTransition__ToAssignment_5 )
+            // InternalRoom.g:16912:2: rule__InitialTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ToAssignment_5();
@@ -46748,14 +46904,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:16922: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:16926:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 )
+            // InternalRoom.g:16927:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__InitialTransition__Group__6__Impl();
@@ -46786,29 +46942,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:16934: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:16938:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:16939:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:16892:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:16893:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            // InternalRoom.g:16939:1: ( ( rule__InitialTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:16940: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:16941:1: ( rule__InitialTransition__DocuAssignment_6 )?
+            int alt169=2;
+            int LA169_0 = input.LA(1);
 
-            if ( (LA168_0==62) ) {
-                alt168=1;
+            if ( (LA169_0==62) ) {
+                alt169=1;
             }
-            switch (alt168) {
+            switch (alt169) {
                 case 1 :
-                    // InternalRoom.g:16894:2: rule__InitialTransition__DocuAssignment_6
+                    // InternalRoom.g:16941:2: rule__InitialTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__DocuAssignment_6();
@@ -46844,14 +47000,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:16951: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:16955:1: ( rule__InitialTransition__Group__7__Impl )
+            // InternalRoom.g:16956:2: rule__InitialTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group__7__Impl();
@@ -46877,29 +47033,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:16962: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:16966:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) )
+            // InternalRoom.g:16967: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:16967:1: ( ( rule__InitialTransition__Group_7__0 )? )
+            // InternalRoom.g:16968: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:16969:1: ( rule__InitialTransition__Group_7__0 )?
+            int alt170=2;
+            int LA170_0 = input.LA(1);
 
-            if ( (LA169_0==44) ) {
-                alt169=1;
+            if ( (LA170_0==44) ) {
+                alt170=1;
             }
-            switch (alt169) {
+            switch (alt170) {
                 case 1 :
-                    // InternalRoom.g:16922:2: rule__InitialTransition__Group_7__0
+                    // InternalRoom.g:16969:2: rule__InitialTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7__0();
@@ -46935,14 +47091,14 @@ 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:16995: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:16999:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 )
+            // InternalRoom.g:17000:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1
             {
             pushFollow(FOLLOW_89);
             rule__InitialTransition__Group_7__0__Impl();
@@ -46973,17 +47129,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:17007: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:17011:1: ( ( '{' ) )
+            // InternalRoom.g:17012:1: ( '{' )
             {
-            // InternalRoom.g:16965:1: ( '{' )
-            // InternalRoom.g:16966:1: '{'
+            // InternalRoom.g:17012:1: ( '{' )
+            // InternalRoom.g:17013:1: '{'
             {
              before(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,44,FOLLOW_2); 
@@ -47010,14 +47166,14 @@ 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:17026: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:17030:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 )
+            // InternalRoom.g:17031:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2
             {
             pushFollow(FOLLOW_89);
             rule__InitialTransition__Group_7__1__Impl();
@@ -47048,29 +47204,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:17038: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:17042:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) )
+            // InternalRoom.g:17043: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:17043:1: ( ( rule__InitialTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17044: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:17045:1: ( rule__InitialTransition__Group_7_1__0 )?
+            int alt171=2;
+            int LA171_0 = input.LA(1);
 
-            if ( (LA170_0==107) ) {
-                alt170=1;
+            if ( (LA171_0==107) ) {
+                alt171=1;
             }
-            switch (alt170) {
+            switch (alt171) {
                 case 1 :
-                    // InternalRoom.g:16998:2: rule__InitialTransition__Group_7_1__0
+                    // InternalRoom.g:17045:2: rule__InitialTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InitialTransition__Group_7_1__0();
@@ -47106,14 +47262,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:17055: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:17059:1: ( rule__InitialTransition__Group_7__2__Impl )
+            // InternalRoom.g:17060:2: rule__InitialTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7__2__Impl();
@@ -47139,17 +47295,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:17066: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:17070:1: ( ( '}' ) )
+            // InternalRoom.g:17071:1: ( '}' )
             {
-            // InternalRoom.g:17024:1: ( '}' )
-            // InternalRoom.g:17025:1: '}'
+            // InternalRoom.g:17071:1: ( '}' )
+            // InternalRoom.g:17072:1: '}'
             {
              before(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,45,FOLLOW_2); 
@@ -47176,14 +47332,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:17091: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:17095:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 )
+            // InternalRoom.g:17096: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 +47370,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:17103: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:17107:1: ( ( 'action' ) )
+            // InternalRoom.g:17108:1: ( 'action' )
             {
-            // InternalRoom.g:17061:1: ( 'action' )
-            // InternalRoom.g:17062:1: 'action'
+            // InternalRoom.g:17108:1: ( 'action' )
+            // InternalRoom.g:17109:1: 'action'
             {
              before(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,107,FOLLOW_2); 
@@ -47251,14 +47407,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:17122: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:17126:1: ( rule__InitialTransition__Group_7_1__1__Impl )
+            // InternalRoom.g:17127:2: rule__InitialTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__Group_7_1__1__Impl();
@@ -47284,21 +47440,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:17133: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:17137:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalRoom.g:17138: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:17138:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17139: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:17140:1: ( rule__InitialTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17140:2: rule__InitialTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InitialTransition__ActionAssignment_7_1_1();
@@ -47331,14 +47487,14 @@ 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:17154: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:17158:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 )
+            // InternalRoom.g:17159:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1
             {
             pushFollow(FOLLOW_86);
             rule__ContinuationTransition__Group__0__Impl();
@@ -47369,17 +47525,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:17166: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:17170:1: ( ( 'Transition' ) )
+            // InternalRoom.g:17171:1: ( 'Transition' )
             {
-            // InternalRoom.g:17124:1: ( 'Transition' )
-            // InternalRoom.g:17125:1: 'Transition'
+            // InternalRoom.g:17171:1: ( 'Transition' )
+            // InternalRoom.g:17172:1: 'Transition'
             {
              before(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -47406,14 +47562,14 @@ 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:17185: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:17189:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 )
+            // InternalRoom.g:17190:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2
             {
             pushFollow(FOLLOW_86);
             rule__ContinuationTransition__Group__1__Impl();
@@ -47444,29 +47600,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:17197: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:17201:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:17202:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:17155:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
-            // InternalRoom.g:17156:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            // InternalRoom.g:17202:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17203: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:17204:1: ( rule__ContinuationTransition__NameAssignment_1 )?
+            int alt172=2;
+            int LA172_0 = input.LA(1);
 
-            if ( (LA171_0==RULE_ID) ) {
-                alt171=1;
+            if ( (LA172_0==RULE_ID) ) {
+                alt172=1;
             }
-            switch (alt171) {
+            switch (alt172) {
                 case 1 :
-                    // InternalRoom.g:17157:2: rule__ContinuationTransition__NameAssignment_1
+                    // InternalRoom.g:17204:2: rule__ContinuationTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__NameAssignment_1();
@@ -47502,14 +47658,14 @@ 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:17214: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:17218:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 )
+            // InternalRoom.g:17219:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3
             {
             pushFollow(FOLLOW_88);
             rule__ContinuationTransition__Group__2__Impl();
@@ -47540,17 +47696,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__2__Impl"
-    // InternalRoom.g:17179:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:17226: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:17230:1: ( ( ':' ) )
+            // InternalRoom.g:17231:1: ( ':' )
             {
-            // InternalRoom.g:17184:1: ( ':' )
-            // InternalRoom.g:17185:1: ':'
+            // InternalRoom.g:17231:1: ( ':' )
+            // InternalRoom.g:17232:1: ':'
             {
              before(grammarAccess.getContinuationTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -47577,14 +47733,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:17245: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:17249:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 )
+            // InternalRoom.g:17250:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__ContinuationTransition__Group__3__Impl();
@@ -47615,21 +47771,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:17257: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:17261:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:17262:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:17215:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
-            // InternalRoom.g:17216:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalRoom.g:17262:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17263: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:17264:1: ( rule__ContinuationTransition__FromAssignment_3 )
+            // InternalRoom.g:17264:2: rule__ContinuationTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__FromAssignment_3();
@@ -47662,14 +47818,14 @@ 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:17274: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:17278:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 )
+            // InternalRoom.g:17279:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5
             {
             pushFollow(FOLLOW_88);
             rule__ContinuationTransition__Group__4__Impl();
@@ -47700,17 +47856,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__Group__4__Impl"
-    // InternalRoom.g:17239:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:17286: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:17290:1: ( ( '->' ) )
+            // InternalRoom.g:17291:1: ( '->' )
             {
-            // InternalRoom.g:17244:1: ( '->' )
-            // InternalRoom.g:17245:1: '->'
+            // InternalRoom.g:17291:1: ( '->' )
+            // InternalRoom.g:17292:1: '->'
             {
              before(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -47737,14 +47893,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:17305: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:17309:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 )
+            // InternalRoom.g:17310:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__ContinuationTransition__Group__5__Impl();
@@ -47775,21 +47931,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:17317: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:17321:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:17322:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:17275:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
-            // InternalRoom.g:17276:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalRoom.g:17322:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17323: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:17324:1: ( rule__ContinuationTransition__ToAssignment_5 )
+            // InternalRoom.g:17324:2: rule__ContinuationTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ToAssignment_5();
@@ -47822,14 +47978,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:17334: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:17338:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 )
+            // InternalRoom.g:17339:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__ContinuationTransition__Group__6__Impl();
@@ -47860,29 +48016,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:17346: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:17350:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:17351:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:17304:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:17305:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            // InternalRoom.g:17351:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17352: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:17353:1: ( rule__ContinuationTransition__DocuAssignment_6 )?
+            int alt173=2;
+            int LA173_0 = input.LA(1);
 
-            if ( (LA172_0==62) ) {
-                alt172=1;
+            if ( (LA173_0==62) ) {
+                alt173=1;
             }
-            switch (alt172) {
+            switch (alt173) {
                 case 1 :
-                    // InternalRoom.g:17306:2: rule__ContinuationTransition__DocuAssignment_6
+                    // InternalRoom.g:17353:2: rule__ContinuationTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__DocuAssignment_6();
@@ -47918,14 +48074,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:17363: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:17367:1: ( rule__ContinuationTransition__Group__7__Impl )
+            // InternalRoom.g:17368:2: rule__ContinuationTransition__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group__7__Impl();
@@ -47951,29 +48107,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:17374: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:17378:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) )
+            // InternalRoom.g:17379: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:17379:1: ( ( rule__ContinuationTransition__Group_7__0 )? )
+            // InternalRoom.g:17380: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:17381:1: ( rule__ContinuationTransition__Group_7__0 )?
+            int alt174=2;
+            int LA174_0 = input.LA(1);
 
-            if ( (LA173_0==44) ) {
-                alt173=1;
+            if ( (LA174_0==44) ) {
+                alt174=1;
             }
-            switch (alt173) {
+            switch (alt174) {
                 case 1 :
-                    // InternalRoom.g:17334:2: rule__ContinuationTransition__Group_7__0
+                    // InternalRoom.g:17381:2: rule__ContinuationTransition__Group_7__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7__0();
@@ -48009,14 +48165,14 @@ 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:17407: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:17411:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 )
+            // InternalRoom.g:17412:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1
             {
             pushFollow(FOLLOW_89);
             rule__ContinuationTransition__Group_7__0__Impl();
@@ -48047,17 +48203,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:17419: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:17423:1: ( ( '{' ) )
+            // InternalRoom.g:17424:1: ( '{' )
             {
-            // InternalRoom.g:17377:1: ( '{' )
-            // InternalRoom.g:17378:1: '{'
+            // InternalRoom.g:17424:1: ( '{' )
+            // InternalRoom.g:17425:1: '{'
             {
              before(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); 
             match(input,44,FOLLOW_2); 
@@ -48084,14 +48240,14 @@ 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:17438: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:17442:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 )
+            // InternalRoom.g:17443:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2
             {
             pushFollow(FOLLOW_89);
             rule__ContinuationTransition__Group_7__1__Impl();
@@ -48122,29 +48278,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:17450: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:17454:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) )
+            // InternalRoom.g:17455: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:17455:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? )
+            // InternalRoom.g:17456: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:17457:1: ( rule__ContinuationTransition__Group_7_1__0 )?
+            int alt175=2;
+            int LA175_0 = input.LA(1);
 
-            if ( (LA174_0==107) ) {
-                alt174=1;
+            if ( (LA175_0==107) ) {
+                alt175=1;
             }
-            switch (alt174) {
+            switch (alt175) {
                 case 1 :
-                    // InternalRoom.g:17410:2: rule__ContinuationTransition__Group_7_1__0
+                    // InternalRoom.g:17457:2: rule__ContinuationTransition__Group_7_1__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ContinuationTransition__Group_7_1__0();
@@ -48180,14 +48336,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:17467: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:17471:1: ( rule__ContinuationTransition__Group_7__2__Impl )
+            // InternalRoom.g:17472:2: rule__ContinuationTransition__Group_7__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7__2__Impl();
@@ -48213,17 +48369,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:17478: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:17482:1: ( ( '}' ) )
+            // InternalRoom.g:17483:1: ( '}' )
             {
-            // InternalRoom.g:17436:1: ( '}' )
-            // InternalRoom.g:17437:1: '}'
+            // InternalRoom.g:17483:1: ( '}' )
+            // InternalRoom.g:17484:1: '}'
             {
              before(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); 
             match(input,45,FOLLOW_2); 
@@ -48250,14 +48406,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:17503: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:17507:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 )
+            // InternalRoom.g:17508: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 +48444,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:17515: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:17519:1: ( ( 'action' ) )
+            // InternalRoom.g:17520:1: ( 'action' )
             {
-            // InternalRoom.g:17473:1: ( 'action' )
-            // InternalRoom.g:17474:1: 'action'
+            // InternalRoom.g:17520:1: ( 'action' )
+            // InternalRoom.g:17521:1: 'action'
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); 
             match(input,107,FOLLOW_2); 
@@ -48325,14 +48481,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:17534: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:17538:1: ( rule__ContinuationTransition__Group_7_1__1__Impl )
+            // InternalRoom.g:17539:2: rule__ContinuationTransition__Group_7_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__Group_7_1__1__Impl();
@@ -48358,21 +48514,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:17545: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:17549:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) )
+            // InternalRoom.g:17550: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:17550:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) )
+            // InternalRoom.g:17551: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:17552:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 )
+            // InternalRoom.g:17552:2: rule__ContinuationTransition__ActionAssignment_7_1_1
             {
             pushFollow(FOLLOW_2);
             rule__ContinuationTransition__ActionAssignment_7_1_1();
@@ -48405,14 +48561,14 @@ 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:17566: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:17570:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 )
+            // InternalRoom.g:17571:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1
             {
             pushFollow(FOLLOW_86);
             rule__TriggeredTransition__Group__0__Impl();
@@ -48443,17 +48599,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:17578: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:17582:1: ( ( 'Transition' ) )
+            // InternalRoom.g:17583:1: ( 'Transition' )
             {
-            // InternalRoom.g:17536:1: ( 'Transition' )
-            // InternalRoom.g:17537:1: 'Transition'
+            // InternalRoom.g:17583:1: ( 'Transition' )
+            // InternalRoom.g:17584:1: 'Transition'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -48480,14 +48636,14 @@ 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:17597: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:17601:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 )
+            // InternalRoom.g:17602:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2
             {
             pushFollow(FOLLOW_86);
             rule__TriggeredTransition__Group__1__Impl();
@@ -48518,29 +48674,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:17609: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:17613:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:17614:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:17567:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
-            // InternalRoom.g:17568:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            // InternalRoom.g:17614:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? )
+            // InternalRoom.g:17615: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:17616:1: ( rule__TriggeredTransition__NameAssignment_1 )?
+            int alt176=2;
+            int LA176_0 = input.LA(1);
 
-            if ( (LA175_0==RULE_ID) ) {
-                alt175=1;
+            if ( (LA176_0==RULE_ID) ) {
+                alt176=1;
             }
-            switch (alt175) {
+            switch (alt176) {
                 case 1 :
-                    // InternalRoom.g:17569:2: rule__TriggeredTransition__NameAssignment_1
+                    // InternalRoom.g:17616:2: rule__TriggeredTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__NameAssignment_1();
@@ -48576,14 +48732,14 @@ 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:17626: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:17630:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 )
+            // InternalRoom.g:17631:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3
             {
             pushFollow(FOLLOW_88);
             rule__TriggeredTransition__Group__2__Impl();
@@ -48614,17 +48770,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__2__Impl"
-    // InternalRoom.g:17591:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:17638: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:17642:1: ( ( ':' ) )
+            // InternalRoom.g:17643:1: ( ':' )
             {
-            // InternalRoom.g:17596:1: ( ':' )
-            // InternalRoom.g:17597:1: ':'
+            // InternalRoom.g:17643:1: ( ':' )
+            // InternalRoom.g:17644:1: ':'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -48651,14 +48807,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:17657: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:17661:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 )
+            // InternalRoom.g:17662:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__TriggeredTransition__Group__3__Impl();
@@ -48689,21 +48845,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:17669: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:17673:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:17674:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:17627:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
-            // InternalRoom.g:17628:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalRoom.g:17674:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) )
+            // InternalRoom.g:17675: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:17676:1: ( rule__TriggeredTransition__FromAssignment_3 )
+            // InternalRoom.g:17676:2: rule__TriggeredTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__FromAssignment_3();
@@ -48736,14 +48892,14 @@ 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:17686: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:17690:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 )
+            // InternalRoom.g:17691:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5
             {
             pushFollow(FOLLOW_88);
             rule__TriggeredTransition__Group__4__Impl();
@@ -48774,17 +48930,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__4__Impl"
-    // InternalRoom.g:17651:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:17698: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:17702:1: ( ( '->' ) )
+            // InternalRoom.g:17703:1: ( '->' )
             {
-            // InternalRoom.g:17656:1: ( '->' )
-            // InternalRoom.g:17657:1: '->'
+            // InternalRoom.g:17703:1: ( '->' )
+            // InternalRoom.g:17704:1: '->'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -48811,14 +48967,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:17717: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:17721:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 )
+            // InternalRoom.g:17722:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__TriggeredTransition__Group__5__Impl();
@@ -48849,21 +49005,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:17729: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:17733:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:17734:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:17687:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
-            // InternalRoom.g:17688:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalRoom.g:17734:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) )
+            // InternalRoom.g:17735: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:17736:1: ( rule__TriggeredTransition__ToAssignment_5 )
+            // InternalRoom.g:17736:2: rule__TriggeredTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ToAssignment_5();
@@ -48896,14 +49052,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:17746: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:17750:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 )
+            // InternalRoom.g:17751:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__TriggeredTransition__Group__6__Impl();
@@ -48934,29 +49090,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:17758: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:17762:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:17763:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:17716:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:17717:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            // InternalRoom.g:17763:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:17764: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:17765:1: ( rule__TriggeredTransition__DocuAssignment_6 )?
+            int alt177=2;
+            int LA177_0 = input.LA(1);
 
-            if ( (LA176_0==62) ) {
-                alt176=1;
+            if ( (LA177_0==62) ) {
+                alt177=1;
             }
-            switch (alt176) {
+            switch (alt177) {
                 case 1 :
-                    // InternalRoom.g:17718:2: rule__TriggeredTransition__DocuAssignment_6
+                    // InternalRoom.g:17765:2: rule__TriggeredTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__DocuAssignment_6();
@@ -48992,14 +49148,14 @@ 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:17775: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:17779:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 )
+            // InternalRoom.g:17780:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8
             {
             pushFollow(FOLLOW_90);
             rule__TriggeredTransition__Group__7__Impl();
@@ -49030,17 +49186,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__7__Impl"
-    // InternalRoom.g:17740:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:17787: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:17791:1: ( ( '{' ) )
+            // InternalRoom.g:17792:1: ( '{' )
             {
-            // InternalRoom.g:17745:1: ( '{' )
-            // InternalRoom.g:17746:1: '{'
+            // InternalRoom.g:17792:1: ( '{' )
+            // InternalRoom.g:17793:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -49067,14 +49223,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:17806: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:17810:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 )
+            // InternalRoom.g:17811:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9
             {
             pushFollow(FOLLOW_40);
             rule__TriggeredTransition__Group__8__Impl();
@@ -49105,17 +49261,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:17818: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:17822:1: ( ( 'triggers' ) )
+            // InternalRoom.g:17823:1: ( 'triggers' )
             {
-            // InternalRoom.g:17776:1: ( 'triggers' )
-            // InternalRoom.g:17777:1: 'triggers'
+            // InternalRoom.g:17823:1: ( 'triggers' )
+            // InternalRoom.g:17824:1: 'triggers'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); 
             match(input,108,FOLLOW_2); 
@@ -49142,14 +49298,14 @@ 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:17837: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:17841:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 )
+            // InternalRoom.g:17842:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10
             {
             pushFollow(FOLLOW_91);
             rule__TriggeredTransition__Group__9__Impl();
@@ -49180,17 +49336,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__9__Impl"
-    // InternalRoom.g:17802:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ;
+    // InternalRoom.g:17849: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:17853:1: ( ( '{' ) )
+            // InternalRoom.g:17854:1: ( '{' )
             {
-            // InternalRoom.g:17807:1: ( '{' )
-            // InternalRoom.g:17808:1: '{'
+            // InternalRoom.g:17854:1: ( '{' )
+            // InternalRoom.g:17855:1: '{'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); 
             match(input,44,FOLLOW_2); 
@@ -49217,14 +49373,14 @@ 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:17868: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:17872:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 )
+            // InternalRoom.g:17873:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11
             {
             pushFollow(FOLLOW_92);
             rule__TriggeredTransition__Group__10__Impl();
@@ -49255,21 +49411,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:17880: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:17884:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) )
+            // InternalRoom.g:17885:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
             {
-            // InternalRoom.g:17838:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
-            // InternalRoom.g:17839:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalRoom.g:17885:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) )
+            // InternalRoom.g:17886: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:17887:1: ( rule__TriggeredTransition__TriggersAssignment_10 )
+            // InternalRoom.g:17887:2: rule__TriggeredTransition__TriggersAssignment_10
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_10();
@@ -49302,14 +49458,14 @@ 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:17897: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:17901:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 )
+            // InternalRoom.g:17902:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12
             {
             pushFollow(FOLLOW_92);
             rule__TriggeredTransition__Group__11__Impl();
@@ -49340,33 +49496,33 @@ 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:17909: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:17913:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) )
+            // InternalRoom.g:17914: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:17914:1: ( ( rule__TriggeredTransition__Group_11__0 )* )
+            // InternalRoom.g:17915:1: ( rule__TriggeredTransition__Group_11__0 )*
             {
              before(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); 
-            // InternalRoom.g:17869:1: ( rule__TriggeredTransition__Group_11__0 )*
-            loop177:
+            // InternalRoom.g:17916:1: ( rule__TriggeredTransition__Group_11__0 )*
+            loop178:
             do {
-                int alt177=2;
-                int LA177_0 = input.LA(1);
+                int alt178=2;
+                int LA178_0 = input.LA(1);
 
-                if ( (LA177_0==109) ) {
-                    alt177=1;
+                if ( (LA178_0==109) ) {
+                    alt178=1;
                 }
 
 
-                switch (alt177) {
+                switch (alt178) {
             	case 1 :
-            	    // InternalRoom.g:17869:2: rule__TriggeredTransition__Group_11__0
+            	    // InternalRoom.g:17916:2: rule__TriggeredTransition__Group_11__0
             	    {
             	    pushFollow(FOLLOW_93);
             	    rule__TriggeredTransition__Group_11__0();
@@ -49378,7 +49534,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop177;
+            	    break loop178;
                 }
             } while (true);
 
@@ -49405,14 +49561,14 @@ 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:17926: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:17930:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 )
+            // InternalRoom.g:17931:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13
             {
             pushFollow(FOLLOW_89);
             rule__TriggeredTransition__Group__12__Impl();
@@ -49443,17 +49599,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__12__Impl"
-    // InternalRoom.g:17891:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ;
+    // InternalRoom.g:17938: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:17942:1: ( ( '}' ) )
+            // InternalRoom.g:17943:1: ( '}' )
             {
-            // InternalRoom.g:17896:1: ( '}' )
-            // InternalRoom.g:17897:1: '}'
+            // InternalRoom.g:17943:1: ( '}' )
+            // InternalRoom.g:17944:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); 
             match(input,45,FOLLOW_2); 
@@ -49480,14 +49636,14 @@ 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:17957: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:17961:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 )
+            // InternalRoom.g:17962:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14
             {
             pushFollow(FOLLOW_89);
             rule__TriggeredTransition__Group__13__Impl();
@@ -49518,29 +49674,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:17969: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:17973:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) )
+            // InternalRoom.g:17974: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:17974:1: ( ( rule__TriggeredTransition__Group_13__0 )? )
+            // InternalRoom.g:17975: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:17976:1: ( rule__TriggeredTransition__Group_13__0 )?
+            int alt179=2;
+            int LA179_0 = input.LA(1);
 
-            if ( (LA178_0==107) ) {
-                alt178=1;
+            if ( (LA179_0==107) ) {
+                alt179=1;
             }
-            switch (alt178) {
+            switch (alt179) {
                 case 1 :
-                    // InternalRoom.g:17929:2: rule__TriggeredTransition__Group_13__0
+                    // InternalRoom.g:17976:2: rule__TriggeredTransition__Group_13__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__TriggeredTransition__Group_13__0();
@@ -49576,14 +49732,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:17986: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:17990:1: ( rule__TriggeredTransition__Group__14__Impl )
+            // InternalRoom.g:17991:2: rule__TriggeredTransition__Group__14__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group__14__Impl();
@@ -49609,17 +49765,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__Group__14__Impl"
-    // InternalRoom.g:17950:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ;
+    // InternalRoom.g:17997: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:18001:1: ( ( '}' ) )
+            // InternalRoom.g:18002:1: ( '}' )
             {
-            // InternalRoom.g:17955:1: ( '}' )
-            // InternalRoom.g:17956:1: '}'
+            // InternalRoom.g:18002:1: ( '}' )
+            // InternalRoom.g:18003:1: '}'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); 
             match(input,45,FOLLOW_2); 
@@ -49646,14 +49802,14 @@ 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:18046: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:18050:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 )
+            // InternalRoom.g:18051:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1
             {
             pushFollow(FOLLOW_91);
             rule__TriggeredTransition__Group_11__0__Impl();
@@ -49684,17 +49840,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:18058: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:18062:1: ( ( 'or' ) )
+            // InternalRoom.g:18063:1: ( 'or' )
             {
-            // InternalRoom.g:18016:1: ( 'or' )
-            // InternalRoom.g:18017:1: 'or'
+            // InternalRoom.g:18063:1: ( 'or' )
+            // InternalRoom.g:18064:1: 'or'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); 
             match(input,109,FOLLOW_2); 
@@ -49721,14 +49877,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:18077: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:18081:1: ( rule__TriggeredTransition__Group_11__1__Impl )
+            // InternalRoom.g:18082:2: rule__TriggeredTransition__Group_11__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_11__1__Impl();
@@ -49754,21 +49910,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:18088: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:18092:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) )
+            // InternalRoom.g:18093: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:18093:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) )
+            // InternalRoom.g:18094: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:18095:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 )
+            // InternalRoom.g:18095:2: rule__TriggeredTransition__TriggersAssignment_11_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__TriggersAssignment_11_1();
@@ -49801,14 +49957,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:18109: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:18113:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 )
+            // InternalRoom.g:18114:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1
             {
             pushFollow(FOLLOW_27);
             rule__TriggeredTransition__Group_13__0__Impl();
@@ -49839,17 +49995,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:18121: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:18125:1: ( ( 'action' ) )
+            // InternalRoom.g:18126:1: ( 'action' )
             {
-            // InternalRoom.g:18079:1: ( 'action' )
-            // InternalRoom.g:18080:1: 'action'
+            // InternalRoom.g:18126:1: ( 'action' )
+            // InternalRoom.g:18127:1: 'action'
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); 
             match(input,107,FOLLOW_2); 
@@ -49876,14 +50032,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:18140: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:18144:1: ( rule__TriggeredTransition__Group_13__1__Impl )
+            // InternalRoom.g:18145:2: rule__TriggeredTransition__Group_13__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__Group_13__1__Impl();
@@ -49909,21 +50065,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:18151: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:18155:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) )
+            // InternalRoom.g:18156: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:18156:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) )
+            // InternalRoom.g:18157: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:18158:1: ( rule__TriggeredTransition__ActionAssignment_13_1 )
+            // InternalRoom.g:18158:2: rule__TriggeredTransition__ActionAssignment_13_1
             {
             pushFollow(FOLLOW_2);
             rule__TriggeredTransition__ActionAssignment_13_1();
@@ -49956,14 +50112,14 @@ 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:18172: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:18176:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 )
+            // InternalRoom.g:18177:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1
             {
             pushFollow(FOLLOW_86);
             rule__GuardedTransition__Group__0__Impl();
@@ -49994,17 +50150,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:18184: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:18188:1: ( ( 'Transition' ) )
+            // InternalRoom.g:18189:1: ( 'Transition' )
             {
-            // InternalRoom.g:18142:1: ( 'Transition' )
-            // InternalRoom.g:18143:1: 'Transition'
+            // InternalRoom.g:18189:1: ( 'Transition' )
+            // InternalRoom.g:18190:1: 'Transition'
             {
              before(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -50031,14 +50187,14 @@ 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:18203: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:18207:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 )
+            // InternalRoom.g:18208:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2
             {
             pushFollow(FOLLOW_86);
             rule__GuardedTransition__Group__1__Impl();
@@ -50069,29 +50225,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:18215: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:18219:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:18220:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:18173:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
-            // InternalRoom.g:18174:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            // InternalRoom.g:18220:1: ( ( rule__GuardedTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18221: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:18222:1: ( rule__GuardedTransition__NameAssignment_1 )?
+            int alt180=2;
+            int LA180_0 = input.LA(1);
 
-            if ( (LA179_0==RULE_ID) ) {
-                alt179=1;
+            if ( (LA180_0==RULE_ID) ) {
+                alt180=1;
             }
-            switch (alt179) {
+            switch (alt180) {
                 case 1 :
-                    // InternalRoom.g:18175:2: rule__GuardedTransition__NameAssignment_1
+                    // InternalRoom.g:18222:2: rule__GuardedTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__NameAssignment_1();
@@ -50127,14 +50283,14 @@ 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:18232: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:18236:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 )
+            // InternalRoom.g:18237:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3
             {
             pushFollow(FOLLOW_88);
             rule__GuardedTransition__Group__2__Impl();
@@ -50165,17 +50321,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__2__Impl"
-    // InternalRoom.g:18197:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:18244: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:18248:1: ( ( ':' ) )
+            // InternalRoom.g:18249:1: ( ':' )
             {
-            // InternalRoom.g:18202:1: ( ':' )
-            // InternalRoom.g:18203:1: ':'
+            // InternalRoom.g:18249:1: ( ':' )
+            // InternalRoom.g:18250:1: ':'
             {
              before(grammarAccess.getGuardedTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -50202,14 +50358,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:18263: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:18267:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 )
+            // InternalRoom.g:18268:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__GuardedTransition__Group__3__Impl();
@@ -50240,21 +50396,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:18275: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:18279:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:18280:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:18233:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
-            // InternalRoom.g:18234:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalRoom.g:18280:1: ( ( rule__GuardedTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18281: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:18282:1: ( rule__GuardedTransition__FromAssignment_3 )
+            // InternalRoom.g:18282:2: rule__GuardedTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__FromAssignment_3();
@@ -50287,14 +50443,14 @@ 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:18292: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:18296:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 )
+            // InternalRoom.g:18297:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5
             {
             pushFollow(FOLLOW_88);
             rule__GuardedTransition__Group__4__Impl();
@@ -50325,17 +50481,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__4__Impl"
-    // InternalRoom.g:18257:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:18304: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:18308:1: ( ( '->' ) )
+            // InternalRoom.g:18309:1: ( '->' )
             {
-            // InternalRoom.g:18262:1: ( '->' )
-            // InternalRoom.g:18263:1: '->'
+            // InternalRoom.g:18309:1: ( '->' )
+            // InternalRoom.g:18310:1: '->'
             {
              before(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -50362,14 +50518,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:18323: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:18327:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 )
+            // InternalRoom.g:18328:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__GuardedTransition__Group__5__Impl();
@@ -50400,21 +50556,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:18335: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:18339:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:18340:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:18293:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
-            // InternalRoom.g:18294:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalRoom.g:18340:1: ( ( rule__GuardedTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18341: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:18342:1: ( rule__GuardedTransition__ToAssignment_5 )
+            // InternalRoom.g:18342:2: rule__GuardedTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ToAssignment_5();
@@ -50447,14 +50603,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:18352: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:18356:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 )
+            // InternalRoom.g:18357:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__GuardedTransition__Group__6__Impl();
@@ -50485,29 +50641,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:18364: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:18368:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:18369:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:18322:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:18323:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            // InternalRoom.g:18369:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18370: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:18371:1: ( rule__GuardedTransition__DocuAssignment_6 )?
+            int alt181=2;
+            int LA181_0 = input.LA(1);
 
-            if ( (LA180_0==62) ) {
-                alt180=1;
+            if ( (LA181_0==62) ) {
+                alt181=1;
             }
-            switch (alt180) {
+            switch (alt181) {
                 case 1 :
-                    // InternalRoom.g:18324:2: rule__GuardedTransition__DocuAssignment_6
+                    // InternalRoom.g:18371:2: rule__GuardedTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__DocuAssignment_6();
@@ -50543,14 +50699,14 @@ 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:18381: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:18385:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 )
+            // InternalRoom.g:18386:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8
             {
             pushFollow(FOLLOW_94);
             rule__GuardedTransition__Group__7__Impl();
@@ -50581,17 +50737,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__7__Impl"
-    // InternalRoom.g:18346:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:18393: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:18397:1: ( ( '{' ) )
+            // InternalRoom.g:18398:1: ( '{' )
             {
-            // InternalRoom.g:18351:1: ( '{' )
-            // InternalRoom.g:18352:1: '{'
+            // InternalRoom.g:18398:1: ( '{' )
+            // InternalRoom.g:18399:1: '{'
             {
              before(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -50618,14 +50774,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:18412: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:18416:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 )
+            // InternalRoom.g:18417:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9
             {
             pushFollow(FOLLOW_27);
             rule__GuardedTransition__Group__8__Impl();
@@ -50656,17 +50812,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:18424: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:18428:1: ( ( 'guard' ) )
+            // InternalRoom.g:18429:1: ( 'guard' )
             {
-            // InternalRoom.g:18382:1: ( 'guard' )
-            // InternalRoom.g:18383:1: 'guard'
+            // InternalRoom.g:18429:1: ( 'guard' )
+            // InternalRoom.g:18430:1: 'guard'
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); 
             match(input,110,FOLLOW_2); 
@@ -50693,14 +50849,14 @@ 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:18443: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:18447:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 )
+            // InternalRoom.g:18448:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10
             {
             pushFollow(FOLLOW_89);
             rule__GuardedTransition__Group__9__Impl();
@@ -50731,21 +50887,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:18455: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:18459:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) )
+            // InternalRoom.g:18460:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
             {
-            // InternalRoom.g:18413:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
-            // InternalRoom.g:18414:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalRoom.g:18460:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) )
+            // InternalRoom.g:18461: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:18462:1: ( rule__GuardedTransition__GuardAssignment_9 )
+            // InternalRoom.g:18462:2: rule__GuardedTransition__GuardAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__GuardAssignment_9();
@@ -50778,14 +50934,14 @@ 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:18472: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:18476:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 )
+            // InternalRoom.g:18477:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11
             {
             pushFollow(FOLLOW_89);
             rule__GuardedTransition__Group__10__Impl();
@@ -50816,29 +50972,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:18484: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:18488:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) )
+            // InternalRoom.g:18489: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:18489:1: ( ( rule__GuardedTransition__Group_10__0 )? )
+            // InternalRoom.g:18490: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:18491:1: ( rule__GuardedTransition__Group_10__0 )?
+            int alt182=2;
+            int LA182_0 = input.LA(1);
 
-            if ( (LA181_0==107) ) {
-                alt181=1;
+            if ( (LA182_0==107) ) {
+                alt182=1;
             }
-            switch (alt181) {
+            switch (alt182) {
                 case 1 :
-                    // InternalRoom.g:18444:2: rule__GuardedTransition__Group_10__0
+                    // InternalRoom.g:18491:2: rule__GuardedTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__GuardedTransition__Group_10__0();
@@ -50874,14 +51030,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:18501: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:18505:1: ( rule__GuardedTransition__Group__11__Impl )
+            // InternalRoom.g:18506:2: rule__GuardedTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group__11__Impl();
@@ -50907,17 +51063,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__Group__11__Impl"
-    // InternalRoom.g:18465:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ;
+    // InternalRoom.g:18512: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:18516:1: ( ( '}' ) )
+            // InternalRoom.g:18517:1: ( '}' )
             {
-            // InternalRoom.g:18470:1: ( '}' )
-            // InternalRoom.g:18471:1: '}'
+            // InternalRoom.g:18517:1: ( '}' )
+            // InternalRoom.g:18518:1: '}'
             {
              before(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,45,FOLLOW_2); 
@@ -50944,14 +51100,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:18555: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:18559:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 )
+            // InternalRoom.g:18560:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1
             {
             pushFollow(FOLLOW_27);
             rule__GuardedTransition__Group_10__0__Impl();
@@ -50982,17 +51138,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:18567: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:18571:1: ( ( 'action' ) )
+            // InternalRoom.g:18572:1: ( 'action' )
             {
-            // InternalRoom.g:18525:1: ( 'action' )
-            // InternalRoom.g:18526:1: 'action'
+            // InternalRoom.g:18572:1: ( 'action' )
+            // InternalRoom.g:18573:1: 'action'
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); 
             match(input,107,FOLLOW_2); 
@@ -51019,14 +51175,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:18586: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:18590:1: ( rule__GuardedTransition__Group_10__1__Impl )
+            // InternalRoom.g:18591:2: rule__GuardedTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__Group_10__1__Impl();
@@ -51052,21 +51208,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:18597: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:18601:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) )
+            // InternalRoom.g:18602: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:18602:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:18603: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:18604:1: ( rule__GuardedTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:18604:2: rule__GuardedTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__GuardedTransition__ActionAssignment_10_1();
@@ -51099,14 +51255,14 @@ 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:18618: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:18622:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 )
+            // InternalRoom.g:18623:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1
             {
             pushFollow(FOLLOW_86);
             rule__CPBranchTransition__Group__0__Impl();
@@ -51137,17 +51293,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:18630: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:18634:1: ( ( 'Transition' ) )
+            // InternalRoom.g:18635:1: ( 'Transition' )
             {
-            // InternalRoom.g:18588:1: ( 'Transition' )
-            // InternalRoom.g:18589:1: 'Transition'
+            // InternalRoom.g:18635:1: ( 'Transition' )
+            // InternalRoom.g:18636:1: 'Transition'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); 
             match(input,105,FOLLOW_2); 
@@ -51174,14 +51330,14 @@ 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:18649: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:18653:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 )
+            // InternalRoom.g:18654:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2
             {
             pushFollow(FOLLOW_86);
             rule__CPBranchTransition__Group__1__Impl();
@@ -51212,29 +51368,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:18661: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:18665:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) )
+            // InternalRoom.g:18666:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
             {
-            // InternalRoom.g:18619:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
-            // InternalRoom.g:18620:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            // InternalRoom.g:18666:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? )
+            // InternalRoom.g:18667: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:18668:1: ( rule__CPBranchTransition__NameAssignment_1 )?
+            int alt183=2;
+            int LA183_0 = input.LA(1);
 
-            if ( (LA182_0==RULE_ID) ) {
-                alt182=1;
+            if ( (LA183_0==RULE_ID) ) {
+                alt183=1;
             }
-            switch (alt182) {
+            switch (alt183) {
                 case 1 :
-                    // InternalRoom.g:18621:2: rule__CPBranchTransition__NameAssignment_1
+                    // InternalRoom.g:18668:2: rule__CPBranchTransition__NameAssignment_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__NameAssignment_1();
@@ -51270,14 +51426,14 @@ 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:18678: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:18682:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 )
+            // InternalRoom.g:18683:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3
             {
             pushFollow(FOLLOW_88);
             rule__CPBranchTransition__Group__2__Impl();
@@ -51308,17 +51464,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__2__Impl"
-    // InternalRoom.g:18643:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ;
+    // InternalRoom.g:18690: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:18694:1: ( ( ':' ) )
+            // InternalRoom.g:18695:1: ( ':' )
             {
-            // InternalRoom.g:18648:1: ( ':' )
-            // InternalRoom.g:18649:1: ':'
+            // InternalRoom.g:18695:1: ( ':' )
+            // InternalRoom.g:18696:1: ':'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2()); 
             match(input,46,FOLLOW_2); 
@@ -51345,14 +51501,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:18709: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:18713:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 )
+            // InternalRoom.g:18714:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4
             {
             pushFollow(FOLLOW_11);
             rule__CPBranchTransition__Group__3__Impl();
@@ -51383,21 +51539,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:18721: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:18725:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) )
+            // InternalRoom.g:18726:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
             {
-            // InternalRoom.g:18679:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
-            // InternalRoom.g:18680:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalRoom.g:18726:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) )
+            // InternalRoom.g:18727: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:18728:1: ( rule__CPBranchTransition__FromAssignment_3 )
+            // InternalRoom.g:18728:2: rule__CPBranchTransition__FromAssignment_3
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__FromAssignment_3();
@@ -51430,14 +51586,14 @@ 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:18738: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:18742:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 )
+            // InternalRoom.g:18743:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5
             {
             pushFollow(FOLLOW_88);
             rule__CPBranchTransition__Group__4__Impl();
@@ -51468,17 +51624,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__4__Impl"
-    // InternalRoom.g:18703:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ;
+    // InternalRoom.g:18750: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:18754:1: ( ( '->' ) )
+            // InternalRoom.g:18755:1: ( '->' )
             {
-            // InternalRoom.g:18708:1: ( '->' )
-            // InternalRoom.g:18709:1: '->'
+            // InternalRoom.g:18755:1: ( '->' )
+            // InternalRoom.g:18756:1: '->'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); 
             match(input,48,FOLLOW_2); 
@@ -51505,14 +51661,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:18769: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:18773:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 )
+            // InternalRoom.g:18774:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6
             {
             pushFollow(FOLLOW_4);
             rule__CPBranchTransition__Group__5__Impl();
@@ -51543,21 +51699,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:18781: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:18785:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) )
+            // InternalRoom.g:18786:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
             {
-            // InternalRoom.g:18739:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
-            // InternalRoom.g:18740:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalRoom.g:18786:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) )
+            // InternalRoom.g:18787: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:18788:1: ( rule__CPBranchTransition__ToAssignment_5 )
+            // InternalRoom.g:18788:2: rule__CPBranchTransition__ToAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ToAssignment_5();
@@ -51590,14 +51746,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:18798: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:18802:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 )
+            // InternalRoom.g:18803:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7
             {
             pushFollow(FOLLOW_4);
             rule__CPBranchTransition__Group__6__Impl();
@@ -51628,29 +51784,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:18810: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:18814:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) )
+            // InternalRoom.g:18815:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
             {
-            // InternalRoom.g:18768:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
-            // InternalRoom.g:18769:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            // InternalRoom.g:18815:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? )
+            // InternalRoom.g:18816: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:18817:1: ( rule__CPBranchTransition__DocuAssignment_6 )?
+            int alt184=2;
+            int LA184_0 = input.LA(1);
 
-            if ( (LA183_0==62) ) {
-                alt183=1;
+            if ( (LA184_0==62) ) {
+                alt184=1;
             }
-            switch (alt183) {
+            switch (alt184) {
                 case 1 :
-                    // InternalRoom.g:18770:2: rule__CPBranchTransition__DocuAssignment_6
+                    // InternalRoom.g:18817:2: rule__CPBranchTransition__DocuAssignment_6
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__DocuAssignment_6();
@@ -51686,14 +51842,14 @@ 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:18827: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:18831:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 )
+            // InternalRoom.g:18832:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8
             {
             pushFollow(FOLLOW_95);
             rule__CPBranchTransition__Group__7__Impl();
@@ -51724,17 +51880,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__7__Impl"
-    // InternalRoom.g:18792:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ;
+    // InternalRoom.g:18839: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:18843:1: ( ( '{' ) )
+            // InternalRoom.g:18844:1: ( '{' )
             {
-            // InternalRoom.g:18797:1: ( '{' )
-            // InternalRoom.g:18798:1: '{'
+            // InternalRoom.g:18844:1: ( '{' )
+            // InternalRoom.g:18845:1: '{'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); 
             match(input,44,FOLLOW_2); 
@@ -51761,14 +51917,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:18858: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:18862:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 )
+            // InternalRoom.g:18863:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9
             {
             pushFollow(FOLLOW_27);
             rule__CPBranchTransition__Group__8__Impl();
@@ -51799,17 +51955,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:18870: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:18874:1: ( ( 'cond' ) )
+            // InternalRoom.g:18875:1: ( 'cond' )
             {
-            // InternalRoom.g:18828:1: ( 'cond' )
-            // InternalRoom.g:18829:1: 'cond'
+            // InternalRoom.g:18875:1: ( 'cond' )
+            // InternalRoom.g:18876:1: 'cond'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); 
             match(input,111,FOLLOW_2); 
@@ -51836,14 +51992,14 @@ 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:18889: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:18893:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 )
+            // InternalRoom.g:18894:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10
             {
             pushFollow(FOLLOW_89);
             rule__CPBranchTransition__Group__9__Impl();
@@ -51874,21 +52030,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:18901: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:18905:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) )
+            // InternalRoom.g:18906:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
             {
-            // InternalRoom.g:18859:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
-            // InternalRoom.g:18860:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalRoom.g:18906:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) )
+            // InternalRoom.g:18907: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:18908:1: ( rule__CPBranchTransition__ConditionAssignment_9 )
+            // InternalRoom.g:18908:2: rule__CPBranchTransition__ConditionAssignment_9
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ConditionAssignment_9();
@@ -51921,14 +52077,14 @@ 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:18918: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:18922:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 )
+            // InternalRoom.g:18923:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11
             {
             pushFollow(FOLLOW_89);
             rule__CPBranchTransition__Group__10__Impl();
@@ -51959,29 +52115,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:18930: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:18934:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) )
+            // InternalRoom.g:18935: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:18935:1: ( ( rule__CPBranchTransition__Group_10__0 )? )
+            // InternalRoom.g:18936: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:18937:1: ( rule__CPBranchTransition__Group_10__0 )?
+            int alt185=2;
+            int LA185_0 = input.LA(1);
 
-            if ( (LA184_0==107) ) {
-                alt184=1;
+            if ( (LA185_0==107) ) {
+                alt185=1;
             }
-            switch (alt184) {
+            switch (alt185) {
                 case 1 :
-                    // InternalRoom.g:18890:2: rule__CPBranchTransition__Group_10__0
+                    // InternalRoom.g:18937:2: rule__CPBranchTransition__Group_10__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__CPBranchTransition__Group_10__0();
@@ -52017,14 +52173,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:18947: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:18951:1: ( rule__CPBranchTransition__Group__11__Impl )
+            // InternalRoom.g:18952:2: rule__CPBranchTransition__Group__11__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group__11__Impl();
@@ -52050,17 +52206,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__Group__11__Impl"
-    // InternalRoom.g:18911:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ;
+    // InternalRoom.g:18958: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:18962:1: ( ( '}' ) )
+            // InternalRoom.g:18963:1: ( '}' )
             {
-            // InternalRoom.g:18916:1: ( '}' )
-            // InternalRoom.g:18917:1: '}'
+            // InternalRoom.g:18963:1: ( '}' )
+            // InternalRoom.g:18964:1: '}'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); 
             match(input,45,FOLLOW_2); 
@@ -52087,14 +52243,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:19001: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:19005:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 )
+            // InternalRoom.g:19006:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1
             {
             pushFollow(FOLLOW_27);
             rule__CPBranchTransition__Group_10__0__Impl();
@@ -52125,17 +52281,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:19013: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:19017:1: ( ( 'action' ) )
+            // InternalRoom.g:19018:1: ( 'action' )
             {
-            // InternalRoom.g:18971:1: ( 'action' )
-            // InternalRoom.g:18972:1: 'action'
+            // InternalRoom.g:19018:1: ( 'action' )
+            // InternalRoom.g:19019:1: 'action'
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); 
             match(input,107,FOLLOW_2); 
@@ -52162,14 +52318,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:19032: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:19036:1: ( rule__CPBranchTransition__Group_10__1__Impl )
+            // InternalRoom.g:19037:2: rule__CPBranchTransition__Group_10__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__Group_10__1__Impl();
@@ -52195,21 +52351,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:19043: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:19047:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) )
+            // InternalRoom.g:19048: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:19048:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) )
+            // InternalRoom.g:19049: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:19050:1: ( rule__CPBranchTransition__ActionAssignment_10_1 )
+            // InternalRoom.g:19050:2: rule__CPBranchTransition__ActionAssignment_10_1
             {
             pushFollow(FOLLOW_2);
             rule__CPBranchTransition__ActionAssignment_10_1();
@@ -52242,14 +52398,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:19064: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:19068:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 )
+            // InternalRoom.g:19069:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__RefinedTransition__Group__0__Impl();
@@ -52280,17 +52436,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:19076: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:19080:1: ( ( 'RefinedTransition' ) )
+            // InternalRoom.g:19081:1: ( 'RefinedTransition' )
             {
-            // InternalRoom.g:19034:1: ( 'RefinedTransition' )
-            // InternalRoom.g:19035:1: 'RefinedTransition'
+            // InternalRoom.g:19081:1: ( 'RefinedTransition' )
+            // InternalRoom.g:19082:1: 'RefinedTransition'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); 
             match(input,112,FOLLOW_2); 
@@ -52317,14 +52473,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:19095: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:19099:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 )
+            // InternalRoom.g:19100:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__RefinedTransition__Group__1__Impl();
@@ -52355,21 +52511,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:19107: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:19111:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) )
+            // InternalRoom.g:19112:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
             {
-            // InternalRoom.g:19065:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
-            // InternalRoom.g:19066:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalRoom.g:19112:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) )
+            // InternalRoom.g:19113: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:19114:1: ( rule__RefinedTransition__TargetAssignment_1 )
+            // InternalRoom.g:19114:2: rule__RefinedTransition__TargetAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__TargetAssignment_1();
@@ -52402,14 +52558,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:19124: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:19128:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 )
+            // InternalRoom.g:19129:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__RefinedTransition__Group__2__Impl();
@@ -52440,29 +52596,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:19136: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:19140:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) )
+            // InternalRoom.g:19141:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:19094:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
-            // InternalRoom.g:19095:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            // InternalRoom.g:19141:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? )
+            // InternalRoom.g:19142: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:19143:1: ( rule__RefinedTransition__DocuAssignment_2 )?
+            int alt186=2;
+            int LA186_0 = input.LA(1);
 
-            if ( (LA185_0==62) ) {
-                alt185=1;
+            if ( (LA186_0==62) ) {
+                alt186=1;
             }
-            switch (alt185) {
+            switch (alt186) {
                 case 1 :
-                    // InternalRoom.g:19096:2: rule__RefinedTransition__DocuAssignment_2
+                    // InternalRoom.g:19143:2: rule__RefinedTransition__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__RefinedTransition__DocuAssignment_2();
@@ -52498,14 +52654,14 @@ 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:19153: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:19157:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 )
+            // InternalRoom.g:19158:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4
             {
             pushFollow(FOLLOW_96);
             rule__RefinedTransition__Group__3__Impl();
@@ -52536,17 +52692,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__3__Impl"
-    // InternalRoom.g:19118:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:19165: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:19169:1: ( ( '{' ) )
+            // InternalRoom.g:19170:1: ( '{' )
             {
-            // InternalRoom.g:19123:1: ( '{' )
-            // InternalRoom.g:19124:1: '{'
+            // InternalRoom.g:19170:1: ( '{' )
+            // InternalRoom.g:19171:1: '{'
             {
              before(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -52573,14 +52729,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:19184: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:19188:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 )
+            // InternalRoom.g:19189:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5
             {
             pushFollow(FOLLOW_27);
             rule__RefinedTransition__Group__4__Impl();
@@ -52611,17 +52767,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:19196: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:19200:1: ( ( 'action' ) )
+            // InternalRoom.g:19201:1: ( 'action' )
             {
-            // InternalRoom.g:19154:1: ( 'action' )
-            // InternalRoom.g:19155:1: 'action'
+            // InternalRoom.g:19201:1: ( 'action' )
+            // InternalRoom.g:19202:1: 'action'
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); 
             match(input,107,FOLLOW_2); 
@@ -52648,14 +52804,14 @@ 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:19215: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:19219:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 )
+            // InternalRoom.g:19220:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6
             {
             pushFollow(FOLLOW_97);
             rule__RefinedTransition__Group__5__Impl();
@@ -52686,21 +52842,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:19227: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:19231:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) )
+            // InternalRoom.g:19232:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
             {
-            // InternalRoom.g:19185:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
-            // InternalRoom.g:19186:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalRoom.g:19232:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) )
+            // InternalRoom.g:19233: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:19234:1: ( rule__RefinedTransition__ActionAssignment_5 )
+            // InternalRoom.g:19234:2: rule__RefinedTransition__ActionAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__ActionAssignment_5();
@@ -52733,14 +52889,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:19244: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:19248:1: ( rule__RefinedTransition__Group__6__Impl )
+            // InternalRoom.g:19249:2: rule__RefinedTransition__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RefinedTransition__Group__6__Impl();
@@ -52766,17 +52922,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__Group__6__Impl"
-    // InternalRoom.g:19208:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ;
+    // InternalRoom.g:19255: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:19259:1: ( ( '}' ) )
+            // InternalRoom.g:19260:1: ( '}' )
             {
-            // InternalRoom.g:19213:1: ( '}' )
-            // InternalRoom.g:19214:1: '}'
+            // InternalRoom.g:19260:1: ( '}' )
+            // InternalRoom.g:19261:1: '}'
             {
              before(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); 
             match(input,45,FOLLOW_2); 
@@ -52803,14 +52959,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:19288: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:19292:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 )
+            // InternalRoom.g:19293:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__TrPointTerminal__Group__0__Impl();
@@ -52841,17 +52997,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:19300: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:19304:1: ( ( 'my' ) )
+            // InternalRoom.g:19305:1: ( 'my' )
             {
-            // InternalRoom.g:19258:1: ( 'my' )
-            // InternalRoom.g:19259:1: 'my'
+            // InternalRoom.g:19305:1: ( 'my' )
+            // InternalRoom.g:19306:1: 'my'
             {
              before(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); 
             match(input,113,FOLLOW_2); 
@@ -52878,14 +53034,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:19319: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:19323:1: ( rule__TrPointTerminal__Group__1__Impl )
+            // InternalRoom.g:19324:2: rule__TrPointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__Group__1__Impl();
@@ -52911,21 +53067,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:19330: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:19334:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) )
+            // InternalRoom.g:19335:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
             {
-            // InternalRoom.g:19288:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
-            // InternalRoom.g:19289:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalRoom.g:19335:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) )
+            // InternalRoom.g:19336: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:19337:1: ( rule__TrPointTerminal__TrPointAssignment_1 )
+            // InternalRoom.g:19337:2: rule__TrPointTerminal__TrPointAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__TrPointTerminal__TrPointAssignment_1();
@@ -52958,14 +53114,14 @@ 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:19351: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:19355:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 )
+            // InternalRoom.g:19356:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1
             {
             pushFollow(FOLLOW_62);
             rule__SubStateTrPointTerminal__Group__0__Impl();
@@ -52996,21 +53152,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:19363: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:19367:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) )
+            // InternalRoom.g:19368:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
             {
-            // InternalRoom.g:19321:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
-            // InternalRoom.g:19322:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalRoom.g:19368:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) )
+            // InternalRoom.g:19369: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:19370:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 )
+            // InternalRoom.g:19370:2: rule__SubStateTrPointTerminal__TrPointAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__TrPointAssignment_0();
@@ -53043,14 +53199,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:19380: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:19384:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 )
+            // InternalRoom.g:19385:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SubStateTrPointTerminal__Group__1__Impl();
@@ -53081,17 +53237,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:19392: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:19396:1: ( ( 'of' ) )
+            // InternalRoom.g:19397:1: ( 'of' )
             {
-            // InternalRoom.g:19350:1: ( 'of' )
-            // InternalRoom.g:19351:1: 'of'
+            // InternalRoom.g:19397:1: ( 'of' )
+            // InternalRoom.g:19398:1: 'of'
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); 
             match(input,53,FOLLOW_2); 
@@ -53118,14 +53274,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:19411: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:19415:1: ( rule__SubStateTrPointTerminal__Group__2__Impl )
+            // InternalRoom.g:19416:2: rule__SubStateTrPointTerminal__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__Group__2__Impl();
@@ -53151,21 +53307,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:19422: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:19426:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) )
+            // InternalRoom.g:19427:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
             {
-            // InternalRoom.g:19380:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
-            // InternalRoom.g:19381:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalRoom.g:19427:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) )
+            // InternalRoom.g:19428: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:19429:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 )
+            // InternalRoom.g:19429:2: rule__SubStateTrPointTerminal__StateAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SubStateTrPointTerminal__StateAssignment_2();
@@ -53198,14 +53354,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:19445: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:19449:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 )
+            // InternalRoom.g:19450:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__ChoicepointTerminal__Group__0__Impl();
@@ -53236,17 +53392,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:19457: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:19461:1: ( ( 'cp' ) )
+            // InternalRoom.g:19462:1: ( 'cp' )
             {
-            // InternalRoom.g:19415:1: ( 'cp' )
-            // InternalRoom.g:19416:1: 'cp'
+            // InternalRoom.g:19462:1: ( 'cp' )
+            // InternalRoom.g:19463:1: 'cp'
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); 
             match(input,114,FOLLOW_2); 
@@ -53273,14 +53429,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:19476: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:19480:1: ( rule__ChoicepointTerminal__Group__1__Impl )
+            // InternalRoom.g:19481:2: rule__ChoicepointTerminal__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__Group__1__Impl();
@@ -53306,21 +53462,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:19487: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:19491:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) )
+            // InternalRoom.g:19492:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
             {
-            // InternalRoom.g:19445:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
-            // InternalRoom.g:19446:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalRoom.g:19492:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) )
+            // InternalRoom.g:19493: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:19494:1: ( rule__ChoicepointTerminal__CpAssignment_1 )
+            // InternalRoom.g:19494:2: rule__ChoicepointTerminal__CpAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__ChoicepointTerminal__CpAssignment_1();
@@ -53353,14 +53509,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:19508: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:19512:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 )
+            // InternalRoom.g:19513:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Trigger__Group__0__Impl();
@@ -53391,17 +53547,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__0__Impl"
-    // InternalRoom.g:19473:1: rule__Trigger__Group__0__Impl : ( '<' ) ;
+    // InternalRoom.g:19520: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:19524:1: ( ( '<' ) )
+            // InternalRoom.g:19525:1: ( '<' )
             {
-            // InternalRoom.g:19478:1: ( '<' )
-            // InternalRoom.g:19479:1: '<'
+            // InternalRoom.g:19525:1: ( '<' )
+            // InternalRoom.g:19526:1: '<'
             {
              before(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); 
             match(input,115,FOLLOW_2); 
@@ -53428,14 +53584,14 @@ 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:19539: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:19543:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 )
+            // InternalRoom.g:19544:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2
             {
             pushFollow(FOLLOW_98);
             rule__Trigger__Group__1__Impl();
@@ -53466,21 +53622,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:19551: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:19555:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) )
+            // InternalRoom.g:19556:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
             {
-            // InternalRoom.g:19509:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
-            // InternalRoom.g:19510:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalRoom.g:19556:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) )
+            // InternalRoom.g:19557: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:19558:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 )
+            // InternalRoom.g:19558:2: rule__Trigger__MsgFromIfPairsAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_1();
@@ -53513,14 +53669,14 @@ 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:19568: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:19572:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 )
+            // InternalRoom.g:19573:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3
             {
             pushFollow(FOLLOW_98);
             rule__Trigger__Group__2__Impl();
@@ -53551,33 +53707,33 @@ 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:19580: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:19584:1: ( ( ( rule__Trigger__Group_2__0 )* ) )
+            // InternalRoom.g:19585: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:19585:1: ( ( rule__Trigger__Group_2__0 )* )
+            // InternalRoom.g:19586:1: ( rule__Trigger__Group_2__0 )*
             {
              before(grammarAccess.getTriggerAccess().getGroup_2()); 
-            // InternalRoom.g:19540:1: ( rule__Trigger__Group_2__0 )*
-            loop186:
+            // InternalRoom.g:19587:1: ( rule__Trigger__Group_2__0 )*
+            loop187:
             do {
-                int alt186=2;
-                int LA186_0 = input.LA(1);
+                int alt187=2;
+                int LA187_0 = input.LA(1);
 
-                if ( (LA186_0==117) ) {
-                    alt186=1;
+                if ( (LA187_0==117) ) {
+                    alt187=1;
                 }
 
 
-                switch (alt186) {
+                switch (alt187) {
             	case 1 :
-            	    // InternalRoom.g:19540:2: rule__Trigger__Group_2__0
+            	    // InternalRoom.g:19587:2: rule__Trigger__Group_2__0
             	    {
             	    pushFollow(FOLLOW_99);
             	    rule__Trigger__Group_2__0();
@@ -53589,7 +53745,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop186;
+            	    break loop187;
                 }
             } while (true);
 
@@ -53616,14 +53772,14 @@ 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:19597: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:19601:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 )
+            // InternalRoom.g:19602:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4
             {
             pushFollow(FOLLOW_98);
             rule__Trigger__Group__3__Impl();
@@ -53654,29 +53810,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:19609: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:19613:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) )
+            // InternalRoom.g:19614:1: ( ( rule__Trigger__GuardAssignment_3 )? )
             {
-            // InternalRoom.g:19567:1: ( ( rule__Trigger__GuardAssignment_3 )? )
-            // InternalRoom.g:19568:1: ( rule__Trigger__GuardAssignment_3 )?
+            // InternalRoom.g:19614:1: ( ( rule__Trigger__GuardAssignment_3 )? )
+            // InternalRoom.g:19615: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:19616:1: ( rule__Trigger__GuardAssignment_3 )?
+            int alt188=2;
+            int LA188_0 = input.LA(1);
 
-            if ( (LA187_0==110) ) {
-                alt187=1;
+            if ( (LA188_0==110) ) {
+                alt188=1;
             }
-            switch (alt187) {
+            switch (alt188) {
                 case 1 :
-                    // InternalRoom.g:19569:2: rule__Trigger__GuardAssignment_3
+                    // InternalRoom.g:19616:2: rule__Trigger__GuardAssignment_3
                     {
                     pushFollow(FOLLOW_2);
                     rule__Trigger__GuardAssignment_3();
@@ -53712,14 +53868,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:19626: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:19630:1: ( rule__Trigger__Group__4__Impl )
+            // InternalRoom.g:19631:2: rule__Trigger__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group__4__Impl();
@@ -53745,17 +53901,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__Group__4__Impl"
-    // InternalRoom.g:19590:1: rule__Trigger__Group__4__Impl : ( '>' ) ;
+    // InternalRoom.g:19637: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:19641:1: ( ( '>' ) )
+            // InternalRoom.g:19642:1: ( '>' )
             {
-            // InternalRoom.g:19595:1: ( '>' )
-            // InternalRoom.g:19596:1: '>'
+            // InternalRoom.g:19642:1: ( '>' )
+            // InternalRoom.g:19643:1: '>'
             {
              before(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); 
             match(input,116,FOLLOW_2); 
@@ -53782,14 +53938,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:19666: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:19670:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 )
+            // InternalRoom.g:19671:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__Trigger__Group_2__0__Impl();
@@ -53820,17 +53976,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:19678: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:19682:1: ( ( '|' ) )
+            // InternalRoom.g:19683:1: ( '|' )
             {
-            // InternalRoom.g:19636:1: ( '|' )
-            // InternalRoom.g:19637:1: '|'
+            // InternalRoom.g:19683:1: ( '|' )
+            // InternalRoom.g:19684:1: '|'
             {
              before(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); 
             match(input,117,FOLLOW_2); 
@@ -53857,14 +54013,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:19697: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:19701:1: ( rule__Trigger__Group_2__1__Impl )
+            // InternalRoom.g:19702:2: rule__Trigger__Group_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__Group_2__1__Impl();
@@ -53890,21 +54046,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:19708: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:19712:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) )
+            // InternalRoom.g:19713: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:19713:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) )
+            // InternalRoom.g:19714: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:19715:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 )
+            // InternalRoom.g:19715:2: rule__Trigger__MsgFromIfPairsAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Trigger__MsgFromIfPairsAssignment_2_1();
@@ -53937,14 +54093,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:19729: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:19733:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 )
+            // InternalRoom.g:19734:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__MessageFromIf__Group__0__Impl();
@@ -53975,21 +54131,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:19741: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:19745:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) )
+            // InternalRoom.g:19746:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
             {
-            // InternalRoom.g:19699:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
-            // InternalRoom.g:19700:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalRoom.g:19746:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) )
+            // InternalRoom.g:19747: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:19748:1: ( rule__MessageFromIf__MessageAssignment_0 )
+            // InternalRoom.g:19748:2: rule__MessageFromIf__MessageAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__MessageAssignment_0();
@@ -54022,14 +54178,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:19758: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:19762:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 )
+            // InternalRoom.g:19763:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__MessageFromIf__Group__1__Impl();
@@ -54060,17 +54216,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__Group__1__Impl"
-    // InternalRoom.g:19723:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:19770: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:19774:1: ( ( ':' ) )
+            // InternalRoom.g:19775:1: ( ':' )
             {
-            // InternalRoom.g:19728:1: ( ':' )
-            // InternalRoom.g:19729:1: ':'
+            // InternalRoom.g:19775:1: ( ':' )
+            // InternalRoom.g:19776:1: ':'
             {
              before(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -54097,14 +54253,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:19789: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:19793:1: ( rule__MessageFromIf__Group__2__Impl )
+            // InternalRoom.g:19794:2: rule__MessageFromIf__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__Group__2__Impl();
@@ -54130,21 +54286,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:19800: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:19804:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) )
+            // InternalRoom.g:19805:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
             {
-            // InternalRoom.g:19758:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
-            // InternalRoom.g:19759:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalRoom.g:19805:1: ( ( rule__MessageFromIf__FromAssignment_2 ) )
+            // InternalRoom.g:19806: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:19807:1: ( rule__MessageFromIf__FromAssignment_2 )
+            // InternalRoom.g:19807:2: rule__MessageFromIf__FromAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__MessageFromIf__FromAssignment_2();
@@ -54177,14 +54333,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:19823: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:19827:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 )
+            // InternalRoom.g:19828:2: rule__Guard__Group__0__Impl rule__Guard__Group__1
             {
             pushFollow(FOLLOW_27);
             rule__Guard__Group__0__Impl();
@@ -54215,17 +54371,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:19835: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:19839:1: ( ( 'guard' ) )
+            // InternalRoom.g:19840:1: ( 'guard' )
             {
-            // InternalRoom.g:19793:1: ( 'guard' )
-            // InternalRoom.g:19794:1: 'guard'
+            // InternalRoom.g:19840:1: ( 'guard' )
+            // InternalRoom.g:19841:1: 'guard'
             {
              before(grammarAccess.getGuardAccess().getGuardKeyword_0()); 
             match(input,110,FOLLOW_2); 
@@ -54252,14 +54408,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:19854: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:19858:1: ( rule__Guard__Group__1__Impl )
+            // InternalRoom.g:19859:2: rule__Guard__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Guard__Group__1__Impl();
@@ -54285,21 +54441,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:19865: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:19869:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) )
+            // InternalRoom.g:19870:1: ( ( rule__Guard__GuardAssignment_1 ) )
             {
-            // InternalRoom.g:19823:1: ( ( rule__Guard__GuardAssignment_1 ) )
-            // InternalRoom.g:19824:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalRoom.g:19870:1: ( ( rule__Guard__GuardAssignment_1 ) )
+            // InternalRoom.g:19871: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:19872:1: ( rule__Guard__GuardAssignment_1 )
+            // InternalRoom.g:19872:2: rule__Guard__GuardAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Guard__GuardAssignment_1();
@@ -54332,14 +54488,14 @@ 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:19886: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:19890:1: ( rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1 )
+            // InternalRoom.g:19891:2: rule__ProtocolSemantics__Group__0__Impl rule__ProtocolSemantics__Group__1
             {
             pushFollow(FOLLOW_100);
             rule__ProtocolSemantics__Group__0__Impl();
@@ -54370,21 +54526,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__0__Impl"
-    // InternalRoom.g:19851:1: rule__ProtocolSemantics__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:19898: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:19902:1: ( ( () ) )
+            // InternalRoom.g:19903:1: ( () )
             {
-            // InternalRoom.g:19856:1: ( () )
-            // InternalRoom.g:19857:1: ()
+            // InternalRoom.g:19903:1: ( () )
+            // InternalRoom.g:19904:1: ()
             {
              before(grammarAccess.getProtocolSemanticsAccess().getProtocolSemanticsAction_0()); 
-            // InternalRoom.g:19858:1: ()
-            // InternalRoom.g:19860:1: 
+            // InternalRoom.g:19905:1: ()
+            // InternalRoom.g:19907:1: 
             {
             }
 
@@ -54407,14 +54563,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:19917: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:19921:1: ( rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2 )
+            // InternalRoom.g:19922:2: rule__ProtocolSemantics__Group__1__Impl rule__ProtocolSemantics__Group__2
             {
             pushFollow(FOLLOW_40);
             rule__ProtocolSemantics__Group__1__Impl();
@@ -54445,17 +54601,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:19929: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:19933:1: ( ( 'semantics' ) )
+            // InternalRoom.g:19934:1: ( 'semantics' )
             {
-            // InternalRoom.g:19887:1: ( 'semantics' )
-            // InternalRoom.g:19888:1: 'semantics'
+            // InternalRoom.g:19934:1: ( 'semantics' )
+            // InternalRoom.g:19935:1: 'semantics'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getSemanticsKeyword_1()); 
             match(input,118,FOLLOW_2); 
@@ -54482,14 +54638,14 @@ 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:19948: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:19952:1: ( rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3 )
+            // InternalRoom.g:19953:2: rule__ProtocolSemantics__Group__2__Impl rule__ProtocolSemantics__Group__3
             {
             pushFollow(FOLLOW_101);
             rule__ProtocolSemantics__Group__2__Impl();
@@ -54520,17 +54676,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__2__Impl"
-    // InternalRoom.g:19913:1: rule__ProtocolSemantics__Group__2__Impl : ( '{' ) ;
+    // InternalRoom.g:19960: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:19964:1: ( ( '{' ) )
+            // InternalRoom.g:19965:1: ( '{' )
             {
-            // InternalRoom.g:19918:1: ( '{' )
-            // InternalRoom.g:19919:1: '{'
+            // InternalRoom.g:19965:1: ( '{' )
+            // InternalRoom.g:19966:1: '{'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getLeftCurlyBracketKeyword_2()); 
             match(input,44,FOLLOW_2); 
@@ -54557,14 +54713,14 @@ 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:19979: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:19983:1: ( rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4 )
+            // InternalRoom.g:19984:2: rule__ProtocolSemantics__Group__3__Impl rule__ProtocolSemantics__Group__4
             {
             pushFollow(FOLLOW_101);
             rule__ProtocolSemantics__Group__3__Impl();
@@ -54595,33 +54751,33 @@ 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:19991: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:19995:1: ( ( ( rule__ProtocolSemantics__RulesAssignment_3 )* ) )
+            // InternalRoom.g:19996:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
             {
-            // InternalRoom.g:19949:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
-            // InternalRoom.g:19950:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
+            // InternalRoom.g:19996:1: ( ( rule__ProtocolSemantics__RulesAssignment_3 )* )
+            // InternalRoom.g:19997:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRulesAssignment_3()); 
-            // InternalRoom.g:19951:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
-            loop188:
+            // InternalRoom.g:19998:1: ( rule__ProtocolSemantics__RulesAssignment_3 )*
+            loop189:
             do {
-                int alt188=2;
-                int LA188_0 = input.LA(1);
+                int alt189=2;
+                int LA189_0 = input.LA(1);
 
-                if ( ((LA188_0>=119 && LA188_0<=120)) ) {
-                    alt188=1;
+                if ( ((LA189_0>=119 && LA189_0<=120)) ) {
+                    alt189=1;
                 }
 
 
-                switch (alt188) {
+                switch (alt189) {
             	case 1 :
-            	    // InternalRoom.g:19951:2: rule__ProtocolSemantics__RulesAssignment_3
+            	    // InternalRoom.g:19998:2: rule__ProtocolSemantics__RulesAssignment_3
             	    {
             	    pushFollow(FOLLOW_102);
             	    rule__ProtocolSemantics__RulesAssignment_3();
@@ -54633,7 +54789,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop188;
+            	    break loop189;
                 }
             } while (true);
 
@@ -54660,14 +54816,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:20008: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:20012:1: ( rule__ProtocolSemantics__Group__4__Impl )
+            // InternalRoom.g:20013:2: rule__ProtocolSemantics__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ProtocolSemantics__Group__4__Impl();
@@ -54693,17 +54849,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__Group__4__Impl"
-    // InternalRoom.g:19972:1: rule__ProtocolSemantics__Group__4__Impl : ( '}' ) ;
+    // InternalRoom.g:20019: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:20023:1: ( ( '}' ) )
+            // InternalRoom.g:20024:1: ( '}' )
             {
-            // InternalRoom.g:19977:1: ( '}' )
-            // InternalRoom.g:19978:1: '}'
+            // InternalRoom.g:20024:1: ( '}' )
+            // InternalRoom.g:20025:1: '}'
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRightCurlyBracketKeyword_4()); 
             match(input,45,FOLLOW_2); 
@@ -54730,14 +54886,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:20048: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:20052:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 )
+            // InternalRoom.g:20053:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__InSemanticsRule__Group__0__Impl();
@@ -54768,17 +54924,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:20060: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:20064:1: ( ( 'in' ) )
+            // InternalRoom.g:20065:1: ( 'in' )
             {
-            // InternalRoom.g:20018:1: ( 'in' )
-            // InternalRoom.g:20019:1: 'in'
+            // InternalRoom.g:20065:1: ( 'in' )
+            // InternalRoom.g:20066:1: 'in'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); 
             match(input,119,FOLLOW_2); 
@@ -54805,14 +54961,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:20079: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:20083:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 )
+            // InternalRoom.g:20084:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__InSemanticsRule__Group__1__Impl();
@@ -54843,17 +54999,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__Group__1__Impl"
-    // InternalRoom.g:20044:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:20091: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:20095:1: ( ( ':' ) )
+            // InternalRoom.g:20096:1: ( ':' )
             {
-            // InternalRoom.g:20049:1: ( ':' )
-            // InternalRoom.g:20050:1: ':'
+            // InternalRoom.g:20096:1: ( ':' )
+            // InternalRoom.g:20097:1: ':'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -54880,14 +55036,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:20110: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:20114:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 )
+            // InternalRoom.g:20115:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_11);
             rule__InSemanticsRule__Group__2__Impl();
@@ -54918,21 +55074,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:20122: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:20126:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalRoom.g:20127:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:20080:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
-            // InternalRoom.g:20081:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20127:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20128: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:20129:1: ( rule__InSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20129:2: rule__InSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__MsgAssignment_2();
@@ -54965,14 +55121,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:20139: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:20143:1: ( rule__InSemanticsRule__Group__3__Impl )
+            // InternalRoom.g:20144:2: rule__InSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group__3__Impl();
@@ -54998,29 +55154,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:20150: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:20154:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) )
+            // InternalRoom.g:20155: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:20155:1: ( ( rule__InSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20156: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:20157:1: ( rule__InSemanticsRule__Group_3__0 )?
+            int alt190=2;
+            int LA190_0 = input.LA(1);
 
-            if ( (LA189_0==48) ) {
-                alt189=1;
+            if ( (LA190_0==48) ) {
+                alt190=1;
             }
-            switch (alt189) {
+            switch (alt190) {
                 case 1 :
-                    // InternalRoom.g:20110:2: rule__InSemanticsRule__Group_3__0
+                    // InternalRoom.g:20157:2: rule__InSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__InSemanticsRule__Group_3__0();
@@ -55056,14 +55212,14 @@ 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:20175: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:20179:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 )
+            // InternalRoom.g:20180:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1
             {
             pushFollow(FOLLOW_103);
             rule__InSemanticsRule__Group_3__0__Impl();
@@ -55094,17 +55250,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:20187: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:20191:1: ( ( '->' ) )
+            // InternalRoom.g:20192:1: ( '->' )
             {
-            // InternalRoom.g:20145:1: ( '->' )
-            // InternalRoom.g:20146:1: '->'
+            // InternalRoom.g:20192:1: ( '->' )
+            // InternalRoom.g:20193:1: '->'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,48,FOLLOW_2); 
@@ -55131,14 +55287,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:20206: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:20210:1: ( rule__InSemanticsRule__Group_3__1__Impl )
+            // InternalRoom.g:20211:2: rule__InSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3__1__Impl();
@@ -55164,21 +55320,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:20217: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:20221:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalRoom.g:20222: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:20222:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20223: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:20224:1: ( rule__InSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20224:2: rule__InSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Alternatives_3_1();
@@ -55211,14 +55367,14 @@ 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:20238: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:20242:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 )
+            // InternalRoom.g:20243:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1
             {
             pushFollow(FOLLOW_104);
             rule__InSemanticsRule__Group_3_1_1__0__Impl();
@@ -55249,17 +55405,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:20250: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:20254:1: ( ( '(' ) )
+            // InternalRoom.g:20255:1: ( '(' )
             {
-            // InternalRoom.g:20208:1: ( '(' )
-            // InternalRoom.g:20209:1: '('
+            // InternalRoom.g:20255:1: ( '(' )
+            // InternalRoom.g:20256:1: '('
             {
              before(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,50,FOLLOW_2); 
@@ -55286,14 +55442,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:20269: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:20273:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 )
+            // InternalRoom.g:20274: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 +55480,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:20281: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:20285:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalRoom.g:20286: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:20286:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20287: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:20288:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20288:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -55371,14 +55527,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:20298: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:20302:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 )
+            // InternalRoom.g:20303: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 +55565,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:20310: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:20314:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalRoom.g:20315: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:20315:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20316: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:20316:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalRoom.g:20317: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:20318:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20318:2: rule__InSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_19);
             rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -55440,24 +55596,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:20321:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20322: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:20323:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )*
+            loop191:
             do {
-                int alt190=2;
-                int LA190_0 = input.LA(1);
+                int alt191=2;
+                int LA191_0 = input.LA(1);
 
-                if ( (LA190_0==54) ) {
-                    alt190=1;
+                if ( (LA191_0==54) ) {
+                    alt191=1;
                 }
 
 
-                switch (alt190) {
+                switch (alt191) {
             	case 1 :
-            	    // InternalRoom.g:20276:2: rule__InSemanticsRule__Group_3_1_1_2__0
+            	    // InternalRoom.g:20323:2: rule__InSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__InSemanticsRule__Group_3_1_1_2__0();
@@ -55469,7 +55625,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop190;
+            	    break loop191;
                 }
             } while (true);
 
@@ -55499,14 +55655,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:20334: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:20338:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalRoom.g:20339:2: rule__InSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1__3__Impl();
@@ -55532,17 +55688,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:20345: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:20349:1: ( ( ')' ) )
+            // InternalRoom.g:20350:1: ( ')' )
             {
-            // InternalRoom.g:20303:1: ( ')' )
-            // InternalRoom.g:20304:1: ')'
+            // InternalRoom.g:20350:1: ( ')' )
+            // InternalRoom.g:20351:1: ')'
             {
              before(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,51,FOLLOW_2); 
@@ -55569,14 +55725,14 @@ 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:20372: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:20376:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 )
+            // InternalRoom.g:20377:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1
             {
             pushFollow(FOLLOW_104);
             rule__InSemanticsRule__Group_3_1_1_2__0__Impl();
@@ -55607,17 +55763,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:20384: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:20388:1: ( ( ',' ) )
+            // InternalRoom.g:20389:1: ( ',' )
             {
-            // InternalRoom.g:20342:1: ( ',' )
-            // InternalRoom.g:20343:1: ','
+            // InternalRoom.g:20389:1: ( ',' )
+            // InternalRoom.g:20390:1: ','
             {
              before(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -55644,14 +55800,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:20403: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:20407:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalRoom.g:20408:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -55677,21 +55833,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:20414: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:20418:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalRoom.g:20419: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:20419:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20420: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:20421:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20421:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -55724,14 +55880,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:20435: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:20439:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 )
+            // InternalRoom.g:20440:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1
             {
             pushFollow(FOLLOW_8);
             rule__OutSemanticsRule__Group__0__Impl();
@@ -55762,17 +55918,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:20447: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:20451:1: ( ( 'out' ) )
+            // InternalRoom.g:20452:1: ( 'out' )
             {
-            // InternalRoom.g:20405:1: ( 'out' )
-            // InternalRoom.g:20406:1: 'out'
+            // InternalRoom.g:20452:1: ( 'out' )
+            // InternalRoom.g:20453:1: 'out'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); 
             match(input,120,FOLLOW_2); 
@@ -55799,14 +55955,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:20466: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:20470:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 )
+            // InternalRoom.g:20471:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__OutSemanticsRule__Group__1__Impl();
@@ -55837,17 +55993,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__Group__1__Impl"
-    // InternalRoom.g:20431:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ;
+    // InternalRoom.g:20478: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:20482:1: ( ( ':' ) )
+            // InternalRoom.g:20483:1: ( ':' )
             {
-            // InternalRoom.g:20436:1: ( ':' )
-            // InternalRoom.g:20437:1: ':'
+            // InternalRoom.g:20483:1: ( ':' )
+            // InternalRoom.g:20484:1: ':'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); 
             match(input,46,FOLLOW_2); 
@@ -55874,14 +56030,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:20497: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:20501:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 )
+            // InternalRoom.g:20502:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3
             {
             pushFollow(FOLLOW_11);
             rule__OutSemanticsRule__Group__2__Impl();
@@ -55912,21 +56068,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:20509: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:20513:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) )
+            // InternalRoom.g:20514:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
             {
-            // InternalRoom.g:20467:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
-            // InternalRoom.g:20468:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20514:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) )
+            // InternalRoom.g:20515: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:20516:1: ( rule__OutSemanticsRule__MsgAssignment_2 )
+            // InternalRoom.g:20516:2: rule__OutSemanticsRule__MsgAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__MsgAssignment_2();
@@ -55959,14 +56115,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:20526: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:20530:1: ( rule__OutSemanticsRule__Group__3__Impl )
+            // InternalRoom.g:20531:2: rule__OutSemanticsRule__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group__3__Impl();
@@ -55992,29 +56148,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:20537: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:20541:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) )
+            // InternalRoom.g:20542: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:20542:1: ( ( rule__OutSemanticsRule__Group_3__0 )? )
+            // InternalRoom.g:20543: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:20544:1: ( rule__OutSemanticsRule__Group_3__0 )?
+            int alt192=2;
+            int LA192_0 = input.LA(1);
 
-            if ( (LA191_0==48) ) {
-                alt191=1;
+            if ( (LA192_0==48) ) {
+                alt192=1;
             }
-            switch (alt191) {
+            switch (alt192) {
                 case 1 :
-                    // InternalRoom.g:20497:2: rule__OutSemanticsRule__Group_3__0
+                    // InternalRoom.g:20544:2: rule__OutSemanticsRule__Group_3__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__OutSemanticsRule__Group_3__0();
@@ -56050,14 +56206,14 @@ 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:20562: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:20566:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 )
+            // InternalRoom.g:20567:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1
             {
             pushFollow(FOLLOW_103);
             rule__OutSemanticsRule__Group_3__0__Impl();
@@ -56088,17 +56244,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:20574: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:20578:1: ( ( '->' ) )
+            // InternalRoom.g:20579:1: ( '->' )
             {
-            // InternalRoom.g:20532:1: ( '->' )
-            // InternalRoom.g:20533:1: '->'
+            // InternalRoom.g:20579:1: ( '->' )
+            // InternalRoom.g:20580:1: '->'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); 
             match(input,48,FOLLOW_2); 
@@ -56125,14 +56281,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:20593: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:20597:1: ( rule__OutSemanticsRule__Group_3__1__Impl )
+            // InternalRoom.g:20598:2: rule__OutSemanticsRule__Group_3__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3__1__Impl();
@@ -56158,21 +56314,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:20604: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:20608:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) )
+            // InternalRoom.g:20609: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:20609:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) )
+            // InternalRoom.g:20610: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:20611:1: ( rule__OutSemanticsRule__Alternatives_3_1 )
+            // InternalRoom.g:20611:2: rule__OutSemanticsRule__Alternatives_3_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Alternatives_3_1();
@@ -56205,14 +56361,14 @@ 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:20625: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:20629:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 )
+            // InternalRoom.g:20630:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1
             {
             pushFollow(FOLLOW_104);
             rule__OutSemanticsRule__Group_3_1_1__0__Impl();
@@ -56243,17 +56399,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:20637: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:20641:1: ( ( '(' ) )
+            // InternalRoom.g:20642:1: ( '(' )
             {
-            // InternalRoom.g:20595:1: ( '(' )
-            // InternalRoom.g:20596:1: '('
+            // InternalRoom.g:20642:1: ( '(' )
+            // InternalRoom.g:20643:1: '('
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); 
             match(input,50,FOLLOW_2); 
@@ -56280,14 +56436,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:20656: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:20660:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 )
+            // InternalRoom.g:20661: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 +56474,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:20668: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:20672:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) )
+            // InternalRoom.g:20673: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:20673:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) )
+            // InternalRoom.g:20674: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:20675:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 )
+            // InternalRoom.g:20675:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1();
@@ -56365,14 +56521,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:20685: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:20689:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 )
+            // InternalRoom.g:20690: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 +56559,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:20697: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:20701:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) )
+            // InternalRoom.g:20702: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:20702:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) )
+            // InternalRoom.g:20703: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:20703:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) )
+            // InternalRoom.g:20704: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:20705:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )
+            // InternalRoom.g:20705:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             {
             pushFollow(FOLLOW_19);
             rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -56434,24 +56590,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:20708:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* )
+            // InternalRoom.g:20709: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:20710:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )*
+            loop193:
             do {
-                int alt192=2;
-                int LA192_0 = input.LA(1);
+                int alt193=2;
+                int LA193_0 = input.LA(1);
 
-                if ( (LA192_0==54) ) {
-                    alt192=1;
+                if ( (LA193_0==54) ) {
+                    alt193=1;
                 }
 
 
-                switch (alt192) {
+                switch (alt193) {
             	case 1 :
-            	    // InternalRoom.g:20663:2: rule__OutSemanticsRule__Group_3_1_1_2__0
+            	    // InternalRoom.g:20710:2: rule__OutSemanticsRule__Group_3_1_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__OutSemanticsRule__Group_3_1_1_2__0();
@@ -56463,7 +56619,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop192;
+            	    break loop193;
                 }
             } while (true);
 
@@ -56493,14 +56649,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:20721: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:20725:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl )
+            // InternalRoom.g:20726:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1__3__Impl();
@@ -56526,17 +56682,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:20732: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:20736:1: ( ( ')' ) )
+            // InternalRoom.g:20737:1: ( ')' )
             {
-            // InternalRoom.g:20690:1: ( ')' )
-            // InternalRoom.g:20691:1: ')'
+            // InternalRoom.g:20737:1: ( ')' )
+            // InternalRoom.g:20738:1: ')'
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); 
             match(input,51,FOLLOW_2); 
@@ -56563,14 +56719,14 @@ 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:20759: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:20763:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 )
+            // InternalRoom.g:20764:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1
             {
             pushFollow(FOLLOW_104);
             rule__OutSemanticsRule__Group_3_1_1_2__0__Impl();
@@ -56601,17 +56757,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:20771: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:20775:1: ( ( ',' ) )
+            // InternalRoom.g:20776:1: ( ',' )
             {
-            // InternalRoom.g:20729:1: ( ',' )
-            // InternalRoom.g:20730:1: ','
+            // InternalRoom.g:20776:1: ( ',' )
+            // InternalRoom.g:20777:1: ','
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -56638,14 +56794,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:20790: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:20794:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl )
+            // InternalRoom.g:20795:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__Group_3_1_1_2__1__Impl();
@@ -56671,21 +56827,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:20801: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:20805:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) )
+            // InternalRoom.g:20806: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:20806:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) )
+            // InternalRoom.g:20807: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:20808:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 )
+            // InternalRoom.g:20808:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1();
@@ -56718,14 +56874,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:20822: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:20826:1: ( rule__Annotation__Group__0__Impl rule__Annotation__Group__1 )
+            // InternalRoom.g:20827:2: rule__Annotation__Group__0__Impl rule__Annotation__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__Annotation__Group__0__Impl();
@@ -56756,17 +56912,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__Group__0__Impl"
-    // InternalRoom.g:20787:1: rule__Annotation__Group__0__Impl : ( '@' ) ;
+    // InternalRoom.g:20834: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:20838:1: ( ( '@' ) )
+            // InternalRoom.g:20839:1: ( '@' )
             {
-            // InternalRoom.g:20792:1: ( '@' )
-            // InternalRoom.g:20793:1: '@'
+            // InternalRoom.g:20839:1: ( '@' )
+            // InternalRoom.g:20840:1: '@'
             {
              before(grammarAccess.getAnnotationAccess().getCommercialAtKeyword_0()); 
             match(input,121,FOLLOW_2); 
@@ -56793,14 +56949,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:20853: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:20857:1: ( rule__Annotation__Group__1__Impl rule__Annotation__Group__2 )
+            // InternalRoom.g:20858:2: rule__Annotation__Group__1__Impl rule__Annotation__Group__2
             {
             pushFollow(FOLLOW_33);
             rule__Annotation__Group__1__Impl();
@@ -56831,21 +56987,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:20865: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:20869:1: ( ( ( rule__Annotation__TypeAssignment_1 ) ) )
+            // InternalRoom.g:20870:1: ( ( rule__Annotation__TypeAssignment_1 ) )
             {
-            // InternalRoom.g:20823:1: ( ( rule__Annotation__TypeAssignment_1 ) )
-            // InternalRoom.g:20824:1: ( rule__Annotation__TypeAssignment_1 )
+            // InternalRoom.g:20870:1: ( ( rule__Annotation__TypeAssignment_1 ) )
+            // InternalRoom.g:20871: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:20872:1: ( rule__Annotation__TypeAssignment_1 )
+            // InternalRoom.g:20872:2: rule__Annotation__TypeAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__TypeAssignment_1();
@@ -56878,14 +57034,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:20882: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:20886:1: ( rule__Annotation__Group__2__Impl )
+            // InternalRoom.g:20887:2: rule__Annotation__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group__2__Impl();
@@ -56911,29 +57067,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:20893: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:20897:1: ( ( ( rule__Annotation__Group_2__0 )? ) )
+            // InternalRoom.g:20898: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:20898:1: ( ( rule__Annotation__Group_2__0 )? )
+            // InternalRoom.g:20899: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:20900:1: ( rule__Annotation__Group_2__0 )?
+            int alt194=2;
+            int LA194_0 = input.LA(1);
 
-            if ( (LA193_0==50) ) {
-                alt193=1;
+            if ( (LA194_0==50) ) {
+                alt194=1;
             }
-            switch (alt193) {
+            switch (alt194) {
                 case 1 :
-                    // InternalRoom.g:20853:2: rule__Annotation__Group_2__0
+                    // InternalRoom.g:20900:2: rule__Annotation__Group_2__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Annotation__Group_2__0();
@@ -56969,14 +57125,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:20916: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:20920:1: ( rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1 )
+            // InternalRoom.g:20921:2: rule__Annotation__Group_2__0__Impl rule__Annotation__Group_2__1
             {
             pushFollow(FOLLOW_3);
             rule__Annotation__Group_2__0__Impl();
@@ -57007,17 +57163,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:20928: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:20932:1: ( ( '(' ) )
+            // InternalRoom.g:20933:1: ( '(' )
             {
-            // InternalRoom.g:20886:1: ( '(' )
-            // InternalRoom.g:20887:1: '('
+            // InternalRoom.g:20933:1: ( '(' )
+            // InternalRoom.g:20934:1: '('
             {
              before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_2_0()); 
             match(input,50,FOLLOW_2); 
@@ -57044,14 +57200,14 @@ 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:20947: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:20951:1: ( rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2 )
+            // InternalRoom.g:20952:2: rule__Annotation__Group_2__1__Impl rule__Annotation__Group_2__2
             {
             pushFollow(FOLLOW_105);
             rule__Annotation__Group_2__1__Impl();
@@ -57082,21 +57238,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:20959: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:20963:1: ( ( ( rule__Annotation__AttributesAssignment_2_1 ) ) )
+            // InternalRoom.g:20964: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:20964:1: ( ( rule__Annotation__AttributesAssignment_2_1 ) )
+            // InternalRoom.g:20965: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:20966:1: ( rule__Annotation__AttributesAssignment_2_1 )
+            // InternalRoom.g:20966:2: rule__Annotation__AttributesAssignment_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__AttributesAssignment_2_1();
@@ -57129,14 +57285,14 @@ 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:20976: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:20980:1: ( rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3 )
+            // InternalRoom.g:20981:2: rule__Annotation__Group_2__2__Impl rule__Annotation__Group_2__3
             {
             pushFollow(FOLLOW_105);
             rule__Annotation__Group_2__2__Impl();
@@ -57167,33 +57323,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:20988: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:20992:1: ( ( ( rule__Annotation__Group_2_2__0 )* ) )
+            // InternalRoom.g:20993: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:20993:1: ( ( rule__Annotation__Group_2_2__0 )* )
+            // InternalRoom.g:20994: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:20995:1: ( rule__Annotation__Group_2_2__0 )*
+            loop195:
             do {
-                int alt194=2;
-                int LA194_0 = input.LA(1);
+                int alt195=2;
+                int LA195_0 = input.LA(1);
 
-                if ( (LA194_0==54) ) {
-                    alt194=1;
+                if ( (LA195_0==54) ) {
+                    alt195=1;
                 }
 
 
-                switch (alt194) {
+                switch (alt195) {
             	case 1 :
-            	    // InternalRoom.g:20948:2: rule__Annotation__Group_2_2__0
+            	    // InternalRoom.g:20995:2: rule__Annotation__Group_2_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__Annotation__Group_2_2__0();
@@ -57205,7 +57361,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop194;
+            	    break loop195;
                 }
             } while (true);
 
@@ -57232,14 +57388,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:21005: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:21009:1: ( rule__Annotation__Group_2__3__Impl )
+            // InternalRoom.g:21010:2: rule__Annotation__Group_2__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group_2__3__Impl();
@@ -57265,17 +57421,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:21016: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:21020:1: ( ( ')' ) )
+            // InternalRoom.g:21021:1: ( ')' )
             {
-            // InternalRoom.g:20974:1: ( ')' )
-            // InternalRoom.g:20975:1: ')'
+            // InternalRoom.g:21021:1: ( ')' )
+            // InternalRoom.g:21022:1: ')'
             {
              before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_2_3()); 
             match(input,51,FOLLOW_2); 
@@ -57302,14 +57458,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:21043: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:21047:1: ( rule__Annotation__Group_2_2__0__Impl rule__Annotation__Group_2_2__1 )
+            // InternalRoom.g:21048: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 +57496,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:21055: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:21059:1: ( ( ',' ) )
+            // InternalRoom.g:21060:1: ( ',' )
             {
-            // InternalRoom.g:21013:1: ( ',' )
-            // InternalRoom.g:21014:1: ','
+            // InternalRoom.g:21060:1: ( ',' )
+            // InternalRoom.g:21061:1: ','
             {
              before(grammarAccess.getAnnotationAccess().getCommaKeyword_2_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -57377,14 +57533,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:21074: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:21078:1: ( rule__Annotation__Group_2_2__1__Impl )
+            // InternalRoom.g:21079:2: rule__Annotation__Group_2_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__Group_2_2__1__Impl();
@@ -57410,21 +57566,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:21085: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:21089:1: ( ( ( rule__Annotation__AttributesAssignment_2_2_1 ) ) )
+            // InternalRoom.g:21090: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:21090:1: ( ( rule__Annotation__AttributesAssignment_2_2_1 ) )
+            // InternalRoom.g:21091: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:21092:1: ( rule__Annotation__AttributesAssignment_2_2_1 )
+            // InternalRoom.g:21092:2: rule__Annotation__AttributesAssignment_2_2_1
             {
             pushFollow(FOLLOW_2);
             rule__Annotation__AttributesAssignment_2_2_1();
@@ -57457,14 +57613,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:21106: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:21110:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 )
+            // InternalRoom.g:21111:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1
             {
             pushFollow(FOLLOW_20);
             rule__KeyValue__Group__0__Impl();
@@ -57495,21 +57651,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:21118: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:21122:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) )
+            // InternalRoom.g:21123:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
             {
-            // InternalRoom.g:21076:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
-            // InternalRoom.g:21077:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalRoom.g:21123:1: ( ( rule__KeyValue__KeyAssignment_0 ) )
+            // InternalRoom.g:21124: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:21125:1: ( rule__KeyValue__KeyAssignment_0 )
+            // InternalRoom.g:21125:2: rule__KeyValue__KeyAssignment_0
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__KeyAssignment_0();
@@ -57542,14 +57698,14 @@ 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:21135: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:21139:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 )
+            // InternalRoom.g:21140:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2
             {
             pushFollow(FOLLOW_106);
             rule__KeyValue__Group__1__Impl();
@@ -57580,17 +57736,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__Group__1__Impl"
-    // InternalRoom.g:21100:1: rule__KeyValue__Group__1__Impl : ( '=' ) ;
+    // InternalRoom.g:21147: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:21151:1: ( ( '=' ) )
+            // InternalRoom.g:21152:1: ( '=' )
             {
-            // InternalRoom.g:21105:1: ( '=' )
-            // InternalRoom.g:21106:1: '='
+            // InternalRoom.g:21152:1: ( '=' )
+            // InternalRoom.g:21153:1: '='
             {
              before(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); 
             match(input,55,FOLLOW_2); 
@@ -57617,14 +57773,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:21166: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:21170:1: ( rule__KeyValue__Group__2__Impl )
+            // InternalRoom.g:21171:2: rule__KeyValue__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__Group__2__Impl();
@@ -57650,21 +57806,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:21177: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:21181:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) )
+            // InternalRoom.g:21182:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
             {
-            // InternalRoom.g:21135:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
-            // InternalRoom.g:21136:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalRoom.g:21182:1: ( ( rule__KeyValue__ValueAssignment_2 ) )
+            // InternalRoom.g:21183: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:21184:1: ( rule__KeyValue__ValueAssignment_2 )
+            // InternalRoom.g:21184:2: rule__KeyValue__ValueAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__KeyValue__ValueAssignment_2();
@@ -57697,14 +57853,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:21200: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:21204:1: ( rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1 )
+            // InternalRoom.g:21205:2: rule__AnnotationType__Group__0__Impl rule__AnnotationType__Group__1
             {
             pushFollow(FOLLOW_3);
             rule__AnnotationType__Group__0__Impl();
@@ -57735,17 +57891,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:21212: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:21216:1: ( ( 'AnnotationType' ) )
+            // InternalRoom.g:21217:1: ( 'AnnotationType' )
             {
-            // InternalRoom.g:21170:1: ( 'AnnotationType' )
-            // InternalRoom.g:21171:1: 'AnnotationType'
+            // InternalRoom.g:21217:1: ( 'AnnotationType' )
+            // InternalRoom.g:21218:1: 'AnnotationType'
             {
              before(grammarAccess.getAnnotationTypeAccess().getAnnotationTypeKeyword_0()); 
             match(input,122,FOLLOW_2); 
@@ -57772,14 +57928,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:21231: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:21235:1: ( rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2 )
+            // InternalRoom.g:21236:2: rule__AnnotationType__Group__1__Impl rule__AnnotationType__Group__2
             {
             pushFollow(FOLLOW_4);
             rule__AnnotationType__Group__1__Impl();
@@ -57810,21 +57966,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:21243: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:21247:1: ( ( ( rule__AnnotationType__NameAssignment_1 ) ) )
+            // InternalRoom.g:21248:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
             {
-            // InternalRoom.g:21201:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
-            // InternalRoom.g:21202:1: ( rule__AnnotationType__NameAssignment_1 )
+            // InternalRoom.g:21248:1: ( ( rule__AnnotationType__NameAssignment_1 ) )
+            // InternalRoom.g:21249: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:21250:1: ( rule__AnnotationType__NameAssignment_1 )
+            // InternalRoom.g:21250:2: rule__AnnotationType__NameAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__NameAssignment_1();
@@ -57857,14 +58013,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:21260: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:21264:1: ( rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3 )
+            // InternalRoom.g:21265:2: rule__AnnotationType__Group__2__Impl rule__AnnotationType__Group__3
             {
             pushFollow(FOLLOW_4);
             rule__AnnotationType__Group__2__Impl();
@@ -57895,29 +58051,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:21272: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:21276:1: ( ( ( rule__AnnotationType__DocuAssignment_2 )? ) )
+            // InternalRoom.g:21277:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
             {
-            // InternalRoom.g:21230:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
-            // InternalRoom.g:21231:1: ( rule__AnnotationType__DocuAssignment_2 )?
+            // InternalRoom.g:21277:1: ( ( rule__AnnotationType__DocuAssignment_2 )? )
+            // InternalRoom.g:21278: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:21279:1: ( rule__AnnotationType__DocuAssignment_2 )?
+            int alt196=2;
+            int LA196_0 = input.LA(1);
 
-            if ( (LA195_0==62) ) {
-                alt195=1;
+            if ( (LA196_0==62) ) {
+                alt196=1;
             }
-            switch (alt195) {
+            switch (alt196) {
                 case 1 :
-                    // InternalRoom.g:21232:2: rule__AnnotationType__DocuAssignment_2
+                    // InternalRoom.g:21279:2: rule__AnnotationType__DocuAssignment_2
                     {
                     pushFollow(FOLLOW_2);
                     rule__AnnotationType__DocuAssignment_2();
@@ -57953,14 +58109,14 @@ 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:21289: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:21293:1: ( rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4 )
+            // InternalRoom.g:21294:2: rule__AnnotationType__Group__3__Impl rule__AnnotationType__Group__4
             {
             pushFollow(FOLLOW_107);
             rule__AnnotationType__Group__3__Impl();
@@ -57991,17 +58147,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__3__Impl"
-    // InternalRoom.g:21254:1: rule__AnnotationType__Group__3__Impl : ( '{' ) ;
+    // InternalRoom.g:21301: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:21305:1: ( ( '{' ) )
+            // InternalRoom.g:21306:1: ( '{' )
             {
-            // InternalRoom.g:21259:1: ( '{' )
-            // InternalRoom.g:21260:1: '{'
+            // InternalRoom.g:21306:1: ( '{' )
+            // InternalRoom.g:21307:1: '{'
             {
              before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_3()); 
             match(input,44,FOLLOW_2); 
@@ -58028,14 +58184,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:21320: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:21324:1: ( rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5 )
+            // InternalRoom.g:21325:2: rule__AnnotationType__Group__4__Impl rule__AnnotationType__Group__5
             {
             pushFollow(FOLLOW_20);
             rule__AnnotationType__Group__4__Impl();
@@ -58066,17 +58222,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:21332: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:21336:1: ( ( 'target' ) )
+            // InternalRoom.g:21337:1: ( 'target' )
             {
-            // InternalRoom.g:21290:1: ( 'target' )
-            // InternalRoom.g:21291:1: 'target'
+            // InternalRoom.g:21337:1: ( 'target' )
+            // InternalRoom.g:21338:1: 'target'
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetKeyword_4()); 
             match(input,123,FOLLOW_2); 
@@ -58103,14 +58259,14 @@ 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:21351: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:21355:1: ( rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6 )
+            // InternalRoom.g:21356:2: rule__AnnotationType__Group__5__Impl rule__AnnotationType__Group__6
             {
             pushFollow(FOLLOW_108);
             rule__AnnotationType__Group__5__Impl();
@@ -58141,17 +58297,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__5__Impl"
-    // InternalRoom.g:21316:1: rule__AnnotationType__Group__5__Impl : ( '=' ) ;
+    // InternalRoom.g:21363: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:21367:1: ( ( '=' ) )
+            // InternalRoom.g:21368:1: ( '=' )
             {
-            // InternalRoom.g:21321:1: ( '=' )
-            // InternalRoom.g:21322:1: '='
+            // InternalRoom.g:21368:1: ( '=' )
+            // InternalRoom.g:21369:1: '='
             {
              before(grammarAccess.getAnnotationTypeAccess().getEqualsSignKeyword_5()); 
             match(input,55,FOLLOW_2); 
@@ -58178,14 +58334,14 @@ 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:21382: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:21386:1: ( rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7 )
+            // InternalRoom.g:21387:2: rule__AnnotationType__Group__6__Impl rule__AnnotationType__Group__7
             {
             pushFollow(FOLLOW_109);
             rule__AnnotationType__Group__6__Impl();
@@ -58216,21 +58372,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:21394: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:21398:1: ( ( ( rule__AnnotationType__Alternatives_6 ) ) )
+            // InternalRoom.g:21399:1: ( ( rule__AnnotationType__Alternatives_6 ) )
             {
-            // InternalRoom.g:21352:1: ( ( rule__AnnotationType__Alternatives_6 ) )
-            // InternalRoom.g:21353:1: ( rule__AnnotationType__Alternatives_6 )
+            // InternalRoom.g:21399:1: ( ( rule__AnnotationType__Alternatives_6 ) )
+            // InternalRoom.g:21400: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:21401:1: ( rule__AnnotationType__Alternatives_6 )
+            // InternalRoom.g:21401:2: rule__AnnotationType__Alternatives_6
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Alternatives_6();
@@ -58263,14 +58419,14 @@ 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:21411: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:21415:1: ( rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8 )
+            // InternalRoom.g:21416:2: rule__AnnotationType__Group__7__Impl rule__AnnotationType__Group__8
             {
             pushFollow(FOLLOW_109);
             rule__AnnotationType__Group__7__Impl();
@@ -58301,33 +58457,33 @@ 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:21423: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:21427:1: ( ( ( rule__AnnotationType__AttributesAssignment_7 )* ) )
+            // InternalRoom.g:21428:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
             {
-            // InternalRoom.g:21381:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
-            // InternalRoom.g:21382:1: ( rule__AnnotationType__AttributesAssignment_7 )*
+            // InternalRoom.g:21428:1: ( ( rule__AnnotationType__AttributesAssignment_7 )* )
+            // InternalRoom.g:21429:1: ( rule__AnnotationType__AttributesAssignment_7 )*
             {
              before(grammarAccess.getAnnotationTypeAccess().getAttributesAssignment_7()); 
-            // InternalRoom.g:21383:1: ( rule__AnnotationType__AttributesAssignment_7 )*
-            loop196:
+            // InternalRoom.g:21430:1: ( rule__AnnotationType__AttributesAssignment_7 )*
+            loop197:
             do {
-                int alt196=2;
-                int LA196_0 = input.LA(1);
+                int alt197=2;
+                int LA197_0 = input.LA(1);
 
-                if ( (LA196_0==26||LA196_0==37) ) {
-                    alt196=1;
+                if ( (LA197_0==26||LA197_0==37) ) {
+                    alt197=1;
                 }
 
 
-                switch (alt196) {
+                switch (alt197) {
             	case 1 :
-            	    // InternalRoom.g:21383:2: rule__AnnotationType__AttributesAssignment_7
+            	    // InternalRoom.g:21430:2: rule__AnnotationType__AttributesAssignment_7
             	    {
             	    pushFollow(FOLLOW_110);
             	    rule__AnnotationType__AttributesAssignment_7();
@@ -58339,7 +58495,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop196;
+            	    break loop197;
                 }
             } while (true);
 
@@ -58366,14 +58522,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:21440: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:21444:1: ( rule__AnnotationType__Group__8__Impl )
+            // InternalRoom.g:21445:2: rule__AnnotationType__Group__8__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group__8__Impl();
@@ -58399,17 +58555,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__Group__8__Impl"
-    // InternalRoom.g:21404:1: rule__AnnotationType__Group__8__Impl : ( '}' ) ;
+    // InternalRoom.g:21451: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:21455:1: ( ( '}' ) )
+            // InternalRoom.g:21456:1: ( '}' )
             {
-            // InternalRoom.g:21409:1: ( '}' )
-            // InternalRoom.g:21410:1: '}'
+            // InternalRoom.g:21456:1: ( '}' )
+            // InternalRoom.g:21457:1: '}'
             {
              before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_8()); 
             match(input,45,FOLLOW_2); 
@@ -58436,14 +58592,14 @@ 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:21488: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:21492:1: ( rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1 )
+            // InternalRoom.g:21493:2: rule__AnnotationType__Group_6_1__0__Impl rule__AnnotationType__Group_6_1__1
             {
             pushFollow(FOLLOW_111);
             rule__AnnotationType__Group_6_1__0__Impl();
@@ -58474,17 +58630,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:21500: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:21504:1: ( ( '{' ) )
+            // InternalRoom.g:21505:1: ( '{' )
             {
-            // InternalRoom.g:21458:1: ( '{' )
-            // InternalRoom.g:21459:1: '{'
+            // InternalRoom.g:21505:1: ( '{' )
+            // InternalRoom.g:21506:1: '{'
             {
              before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_6_1_0()); 
             match(input,44,FOLLOW_2); 
@@ -58511,14 +58667,14 @@ 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:21519: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:21523:1: ( rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2 )
+            // InternalRoom.g:21524:2: rule__AnnotationType__Group_6_1__1__Impl rule__AnnotationType__Group_6_1__2
             {
             pushFollow(FOLLOW_112);
             rule__AnnotationType__Group_6_1__1__Impl();
@@ -58549,21 +58705,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:21531: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:21535:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) ) )
+            // InternalRoom.g:21536: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:21536:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_1 ) )
+            // InternalRoom.g:21537: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:21538:1: ( rule__AnnotationType__TargetsAssignment_6_1_1 )
+            // InternalRoom.g:21538:2: rule__AnnotationType__TargetsAssignment_6_1_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__TargetsAssignment_6_1_1();
@@ -58596,14 +58752,14 @@ 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:21548: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:21552:1: ( rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3 )
+            // InternalRoom.g:21553:2: rule__AnnotationType__Group_6_1__2__Impl rule__AnnotationType__Group_6_1__3
             {
             pushFollow(FOLLOW_112);
             rule__AnnotationType__Group_6_1__2__Impl();
@@ -58634,33 +58790,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:21560: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:21564:1: ( ( ( rule__AnnotationType__Group_6_1_2__0 )* ) )
+            // InternalRoom.g:21565: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:21565:1: ( ( rule__AnnotationType__Group_6_1_2__0 )* )
+            // InternalRoom.g:21566: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:21567:1: ( rule__AnnotationType__Group_6_1_2__0 )*
+            loop198:
             do {
-                int alt197=2;
-                int LA197_0 = input.LA(1);
+                int alt198=2;
+                int LA198_0 = input.LA(1);
 
-                if ( (LA197_0==54) ) {
-                    alt197=1;
+                if ( (LA198_0==54) ) {
+                    alt198=1;
                 }
 
 
-                switch (alt197) {
+                switch (alt198) {
             	case 1 :
-            	    // InternalRoom.g:21520:2: rule__AnnotationType__Group_6_1_2__0
+            	    // InternalRoom.g:21567:2: rule__AnnotationType__Group_6_1_2__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__AnnotationType__Group_6_1_2__0();
@@ -58672,7 +58828,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop197;
+            	    break loop198;
                 }
             } while (true);
 
@@ -58699,14 +58855,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:21577: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:21581:1: ( rule__AnnotationType__Group_6_1__3__Impl )
+            // InternalRoom.g:21582:2: rule__AnnotationType__Group_6_1__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group_6_1__3__Impl();
@@ -58732,17 +58888,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:21588: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:21592:1: ( ( '}' ) )
+            // InternalRoom.g:21593:1: ( '}' )
             {
-            // InternalRoom.g:21546:1: ( '}' )
-            // InternalRoom.g:21547:1: '}'
+            // InternalRoom.g:21593:1: ( '}' )
+            // InternalRoom.g:21594:1: '}'
             {
              before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_6_1_3()); 
             match(input,45,FOLLOW_2); 
@@ -58769,14 +58925,14 @@ 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:21615: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:21619:1: ( rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1 )
+            // InternalRoom.g:21620:2: rule__AnnotationType__Group_6_1_2__0__Impl rule__AnnotationType__Group_6_1_2__1
             {
             pushFollow(FOLLOW_111);
             rule__AnnotationType__Group_6_1_2__0__Impl();
@@ -58807,17 +58963,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:21627: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:21631:1: ( ( ',' ) )
+            // InternalRoom.g:21632:1: ( ',' )
             {
-            // InternalRoom.g:21585:1: ( ',' )
-            // InternalRoom.g:21586:1: ','
+            // InternalRoom.g:21632:1: ( ',' )
+            // InternalRoom.g:21633:1: ','
             {
              before(grammarAccess.getAnnotationTypeAccess().getCommaKeyword_6_1_2_0()); 
             match(input,54,FOLLOW_2); 
@@ -58844,14 +59000,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:21646: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:21650:1: ( rule__AnnotationType__Group_6_1_2__1__Impl )
+            // InternalRoom.g:21651:2: rule__AnnotationType__Group_6_1_2__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__Group_6_1_2__1__Impl();
@@ -58877,21 +59033,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:21657: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:21661:1: ( ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) ) )
+            // InternalRoom.g:21662: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:21662:1: ( ( rule__AnnotationType__TargetsAssignment_6_1_2_1 ) )
+            // InternalRoom.g:21663: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:21664:1: ( rule__AnnotationType__TargetsAssignment_6_1_2_1 )
+            // InternalRoom.g:21664:2: rule__AnnotationType__TargetsAssignment_6_1_2_1
             {
             pushFollow(FOLLOW_2);
             rule__AnnotationType__TargetsAssignment_6_1_2_1();
@@ -58924,14 +59080,14 @@ 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:21678: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:21682:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 )
+            // InternalRoom.g:21683:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1
             {
             pushFollow(FOLLOW_113);
             rule__SimpleAnnotationAttribute__Group__0__Impl();
@@ -58962,21 +59118,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:21690: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:21694:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalRoom.g:21695:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalRoom.g:21648:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
-            // InternalRoom.g:21649:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21695:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:21696: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:21697:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21697:2: rule__SimpleAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Alternatives_0();
@@ -59009,14 +59165,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:21707: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:21711:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 )
+            // InternalRoom.g:21712:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__SimpleAnnotationAttribute__Group__1__Impl();
@@ -59047,17 +59203,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:21719: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:21723:1: ( ( 'attribute' ) )
+            // InternalRoom.g:21724:1: ( 'attribute' )
             {
-            // InternalRoom.g:21677:1: ( 'attribute' )
-            // InternalRoom.g:21678:1: 'attribute'
+            // InternalRoom.g:21724:1: ( 'attribute' )
+            // InternalRoom.g:21725:1: 'attribute'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,124,FOLLOW_2); 
@@ -59084,14 +59240,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:21738: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:21742:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 )
+            // InternalRoom.g:21743:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__SimpleAnnotationAttribute__Group__2__Impl();
@@ -59122,21 +59278,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:21750: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:21754:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalRoom.g:21755:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalRoom.g:21708:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
-            // InternalRoom.g:21709:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21755:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:21756: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:21757:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21757:2: rule__SimpleAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__NameAssignment_2();
@@ -59169,14 +59325,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:21767: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:21771:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 )
+            // InternalRoom.g:21772:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_10);
             rule__SimpleAnnotationAttribute__Group__3__Impl();
@@ -59207,17 +59363,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3__Impl"
-    // InternalRoom.g:21732:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:21779: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:21783:1: ( ( ':' ) )
+            // InternalRoom.g:21784:1: ( ':' )
             {
-            // InternalRoom.g:21737:1: ( ':' )
-            // InternalRoom.g:21738:1: ':'
+            // InternalRoom.g:21784:1: ( ':' )
+            // InternalRoom.g:21785:1: ':'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -59244,14 +59400,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:21798: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:21802:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl )
+            // InternalRoom.g:21803:2: rule__SimpleAnnotationAttribute__Group__4__Impl
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__Group__4__Impl();
@@ -59277,21 +59433,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:21809: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:21813:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) )
+            // InternalRoom.g:21814:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
             {
-            // InternalRoom.g:21767:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
-            // InternalRoom.g:21768:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalRoom.g:21814:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) )
+            // InternalRoom.g:21815: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:21816:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 )
+            // InternalRoom.g:21816:2: rule__SimpleAnnotationAttribute__TypeAssignment_4
             {
             pushFollow(FOLLOW_2);
             rule__SimpleAnnotationAttribute__TypeAssignment_4();
@@ -59324,14 +59480,14 @@ 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:21836: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:21840:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 )
+            // InternalRoom.g:21841:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1
             {
             pushFollow(FOLLOW_113);
             rule__EnumAnnotationAttribute__Group__0__Impl();
@@ -59362,21 +59518,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:21848: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:21852:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) )
+            // InternalRoom.g:21853:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
             {
-            // InternalRoom.g:21806:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
-            // InternalRoom.g:21807:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21853:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) )
+            // InternalRoom.g:21854: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:21855:1: ( rule__EnumAnnotationAttribute__Alternatives_0 )
+            // InternalRoom.g:21855:2: rule__EnumAnnotationAttribute__Alternatives_0
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Alternatives_0();
@@ -59409,14 +59565,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:21865: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:21869:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 )
+            // InternalRoom.g:21870:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2
             {
             pushFollow(FOLLOW_3);
             rule__EnumAnnotationAttribute__Group__1__Impl();
@@ -59447,17 +59603,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:21877: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:21881:1: ( ( 'attribute' ) )
+            // InternalRoom.g:21882:1: ( 'attribute' )
             {
-            // InternalRoom.g:21835:1: ( 'attribute' )
-            // InternalRoom.g:21836:1: 'attribute'
+            // InternalRoom.g:21882:1: ( 'attribute' )
+            // InternalRoom.g:21883:1: 'attribute'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); 
             match(input,124,FOLLOW_2); 
@@ -59484,14 +59640,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:21896: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:21900:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 )
+            // InternalRoom.g:21901:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3
             {
             pushFollow(FOLLOW_8);
             rule__EnumAnnotationAttribute__Group__2__Impl();
@@ -59522,21 +59678,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:21908: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:21912:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) )
+            // InternalRoom.g:21913:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
             {
-            // InternalRoom.g:21866:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
-            // InternalRoom.g:21867:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21913:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) )
+            // InternalRoom.g:21914: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:21915:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 )
+            // InternalRoom.g:21915:2: rule__EnumAnnotationAttribute__NameAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__NameAssignment_2();
@@ -59569,14 +59725,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:21925: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:21929:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 )
+            // InternalRoom.g:21930:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4
             {
             pushFollow(FOLLOW_40);
             rule__EnumAnnotationAttribute__Group__3__Impl();
@@ -59607,17 +59763,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__3__Impl"
-    // InternalRoom.g:21890:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ;
+    // InternalRoom.g:21937: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:21941:1: ( ( ':' ) )
+            // InternalRoom.g:21942:1: ( ':' )
             {
-            // InternalRoom.g:21895:1: ( ':' )
-            // InternalRoom.g:21896:1: ':'
+            // InternalRoom.g:21942:1: ( ':' )
+            // InternalRoom.g:21943:1: ':'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); 
             match(input,46,FOLLOW_2); 
@@ -59644,14 +59800,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:21956: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:21960:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 )
+            // InternalRoom.g:21961:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5
             {
             pushFollow(FOLLOW_12);
             rule__EnumAnnotationAttribute__Group__4__Impl();
@@ -59682,17 +59838,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__4__Impl"
-    // InternalRoom.g:21921:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ;
+    // InternalRoom.g:21968: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:21972:1: ( ( '{' ) )
+            // InternalRoom.g:21973:1: ( '{' )
             {
-            // InternalRoom.g:21926:1: ( '{' )
-            // InternalRoom.g:21927:1: '{'
+            // InternalRoom.g:21973:1: ( '{' )
+            // InternalRoom.g:21974:1: '{'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); 
             match(input,44,FOLLOW_2); 
@@ -59719,14 +59875,14 @@ 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:21987: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:21991:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 )
+            // InternalRoom.g:21992:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6
             {
             pushFollow(FOLLOW_112);
             rule__EnumAnnotationAttribute__Group__5__Impl();
@@ -59757,21 +59913,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:21999: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:22003:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) )
+            // InternalRoom.g:22004:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
             {
-            // InternalRoom.g:21957:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
-            // InternalRoom.g:21958:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalRoom.g:22004:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) )
+            // InternalRoom.g:22005: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:22006:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 )
+            // InternalRoom.g:22006:2: rule__EnumAnnotationAttribute__ValuesAssignment_5
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_5();
@@ -59804,14 +59960,14 @@ 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:22016: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:22020:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 )
+            // InternalRoom.g:22021:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7
             {
             pushFollow(FOLLOW_112);
             rule__EnumAnnotationAttribute__Group__6__Impl();
@@ -59842,33 +59998,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:22028: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:22032:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) )
+            // InternalRoom.g:22033: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:22033:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* )
+            // InternalRoom.g:22034:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); 
-            // InternalRoom.g:21988:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
-            loop198:
+            // InternalRoom.g:22035:1: ( rule__EnumAnnotationAttribute__Group_6__0 )*
+            loop199:
             do {
-                int alt198=2;
-                int LA198_0 = input.LA(1);
+                int alt199=2;
+                int LA199_0 = input.LA(1);
 
-                if ( (LA198_0==54) ) {
-                    alt198=1;
+                if ( (LA199_0==54) ) {
+                    alt199=1;
                 }
 
 
-                switch (alt198) {
+                switch (alt199) {
             	case 1 :
-            	    // InternalRoom.g:21988:2: rule__EnumAnnotationAttribute__Group_6__0
+            	    // InternalRoom.g:22035:2: rule__EnumAnnotationAttribute__Group_6__0
             	    {
             	    pushFollow(FOLLOW_19);
             	    rule__EnumAnnotationAttribute__Group_6__0();
@@ -59880,7 +60036,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop198;
+            	    break loop199;
                 }
             } while (true);
 
@@ -59907,14 +60063,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:22045: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:22049:1: ( rule__EnumAnnotationAttribute__Group__7__Impl )
+            // InternalRoom.g:22050:2: rule__EnumAnnotationAttribute__Group__7__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group__7__Impl();
@@ -59940,17 +60096,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__Group__7__Impl"
-    // InternalRoom.g:22009:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ;
+    // InternalRoom.g:22056: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:22060:1: ( ( '}' ) )
+            // InternalRoom.g:22061:1: ( '}' )
             {
-            // InternalRoom.g:22014:1: ( '}' )
-            // InternalRoom.g:22015:1: '}'
+            // InternalRoom.g:22061:1: ( '}' )
+            // InternalRoom.g:22062:1: '}'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); 
             match(input,45,FOLLOW_2); 
@@ -59977,14 +60133,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:22091: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:22095:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 )
+            // InternalRoom.g:22096:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1
             {
             pushFollow(FOLLOW_12);
             rule__EnumAnnotationAttribute__Group_6__0__Impl();
@@ -60015,17 +60171,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:22103: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:22107:1: ( ( ',' ) )
+            // InternalRoom.g:22108:1: ( ',' )
             {
-            // InternalRoom.g:22061:1: ( ',' )
-            // InternalRoom.g:22062:1: ','
+            // InternalRoom.g:22108:1: ( ',' )
+            // InternalRoom.g:22109:1: ','
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); 
             match(input,54,FOLLOW_2); 
@@ -60052,14 +60208,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:22122: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:22126:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl )
+            // InternalRoom.g:22127:2: rule__EnumAnnotationAttribute__Group_6__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__Group_6__1__Impl();
@@ -60085,21 +60241,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:22133: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:22137:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) )
+            // InternalRoom.g:22138: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:22138:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) )
+            // InternalRoom.g:22139: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:22140:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 )
+            // InternalRoom.g:22140:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1
             {
             pushFollow(FOLLOW_2);
             rule__EnumAnnotationAttribute__ValuesAssignment_6_1();
@@ -60132,14 +60288,14 @@ 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:22154: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:22158:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 )
+            // InternalRoom.g:22159:2: rule__Import__Group__0__Impl rule__Import__Group__1
             {
             pushFollow(FOLLOW_114);
             rule__Import__Group__0__Impl();
@@ -60170,17 +60326,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:22166: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:22170:1: ( ( 'import' ) )
+            // InternalRoom.g:22171:1: ( 'import' )
             {
-            // InternalRoom.g:22124:1: ( 'import' )
-            // InternalRoom.g:22125:1: 'import'
+            // InternalRoom.g:22171:1: ( 'import' )
+            // InternalRoom.g:22172:1: 'import'
             {
              before(grammarAccess.getImportAccess().getImportKeyword_0()); 
             match(input,125,FOLLOW_2); 
@@ -60207,14 +60363,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:22185: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:22189:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 )
+            // InternalRoom.g:22190:2: rule__Import__Group__1__Impl rule__Import__Group__2
             {
             pushFollow(FOLLOW_12);
             rule__Import__Group__1__Impl();
@@ -60245,21 +60401,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:22197: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:22201:1: ( ( ( rule__Import__Alternatives_1 ) ) )
+            // InternalRoom.g:22202:1: ( ( rule__Import__Alternatives_1 ) )
             {
-            // InternalRoom.g:22155:1: ( ( rule__Import__Alternatives_1 ) )
-            // InternalRoom.g:22156:1: ( rule__Import__Alternatives_1 )
+            // InternalRoom.g:22202:1: ( ( rule__Import__Alternatives_1 ) )
+            // InternalRoom.g:22203: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:22204:1: ( rule__Import__Alternatives_1 )
+            // InternalRoom.g:22204:2: rule__Import__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__Import__Alternatives_1();
@@ -60292,14 +60448,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:22214: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:22218:1: ( rule__Import__Group__2__Impl )
+            // InternalRoom.g:22219:2: rule__Import__Group__2__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group__2__Impl();
@@ -60325,21 +60481,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:22225: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:22229:1: ( ( ( rule__Import__ImportURIAssignment_2 ) ) )
+            // InternalRoom.g:22230:1: ( ( rule__Import__ImportURIAssignment_2 ) )
             {
-            // InternalRoom.g:22183:1: ( ( rule__Import__ImportURIAssignment_2 ) )
-            // InternalRoom.g:22184:1: ( rule__Import__ImportURIAssignment_2 )
+            // InternalRoom.g:22230:1: ( ( rule__Import__ImportURIAssignment_2 ) )
+            // InternalRoom.g:22231: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:22232:1: ( rule__Import__ImportURIAssignment_2 )
+            // InternalRoom.g:22232:2: rule__Import__ImportURIAssignment_2
             {
             pushFollow(FOLLOW_2);
             rule__Import__ImportURIAssignment_2();
@@ -60372,14 +60528,14 @@ 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:22248: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:22252:1: ( rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1 )
+            // InternalRoom.g:22253:2: rule__Import__Group_1_0__0__Impl rule__Import__Group_1_0__1
             {
             pushFollow(FOLLOW_115);
             rule__Import__Group_1_0__0__Impl();
@@ -60410,21 +60566,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:22260: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:22264:1: ( ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) ) )
+            // InternalRoom.g:22265: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:22265:1: ( ( rule__Import__ImportedNamespaceAssignment_1_0_0 ) )
+            // InternalRoom.g:22266: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:22267:1: ( rule__Import__ImportedNamespaceAssignment_1_0_0 )
+            // InternalRoom.g:22267:2: rule__Import__ImportedNamespaceAssignment_1_0_0
             {
             pushFollow(FOLLOW_2);
             rule__Import__ImportedNamespaceAssignment_1_0_0();
@@ -60457,14 +60613,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:22277: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:22281:1: ( rule__Import__Group_1_0__1__Impl )
+            // InternalRoom.g:22282:2: rule__Import__Group_1_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Import__Group_1_0__1__Impl();
@@ -60490,17 +60646,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:22288: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:22292:1: ( ( 'from' ) )
+            // InternalRoom.g:22293:1: ( 'from' )
             {
-            // InternalRoom.g:22246:1: ( 'from' )
-            // InternalRoom.g:22247:1: 'from'
+            // InternalRoom.g:22293:1: ( 'from' )
+            // InternalRoom.g:22294:1: 'from'
             {
              before(grammarAccess.getImportAccess().getFromKeyword_1_0_1()); 
             match(input,126,FOLLOW_2); 
@@ -60527,14 +60683,14 @@ 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:22311: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:22315:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 )
+            // InternalRoom.g:22316:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1
             {
             pushFollow(FOLLOW_116);
             rule__ImportedFQN__Group__0__Impl();
@@ -60565,17 +60721,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:22323: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:22327:1: ( ( ruleFQN ) )
+            // InternalRoom.g:22328:1: ( ruleFQN )
             {
-            // InternalRoom.g:22281:1: ( ruleFQN )
-            // InternalRoom.g:22282:1: ruleFQN
+            // InternalRoom.g:22328:1: ( ruleFQN )
+            // InternalRoom.g:22329:1: ruleFQN
             {
              before(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
             pushFollow(FOLLOW_2);
@@ -60606,14 +60762,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:22340: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:22344:1: ( rule__ImportedFQN__Group__1__Impl )
+            // InternalRoom.g:22345:2: rule__ImportedFQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ImportedFQN__Group__1__Impl();
@@ -60639,29 +60795,29 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ImportedFQN__Group__1__Impl"
-    // InternalRoom.g:22304:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ;
+    // InternalRoom.g:22351: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:22355:1: ( ( ( '.*' )? ) )
+            // InternalRoom.g:22356:1: ( ( '.*' )? )
             {
-            // InternalRoom.g:22309:1: ( ( '.*' )? )
-            // InternalRoom.g:22310:1: ( '.*' )?
+            // InternalRoom.g:22356:1: ( ( '.*' )? )
+            // InternalRoom.g:22357:1: ( '.*' )?
             {
              before(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); 
-            // InternalRoom.g:22311:1: ( '.*' )?
-            int alt199=2;
-            int LA199_0 = input.LA(1);
+            // InternalRoom.g:22358:1: ( '.*' )?
+            int alt200=2;
+            int LA200_0 = input.LA(1);
 
-            if ( (LA199_0==127) ) {
-                alt199=1;
+            if ( (LA200_0==127) ) {
+                alt200=1;
             }
-            switch (alt199) {
+            switch (alt200) {
                 case 1 :
-                    // InternalRoom.g:22312:2: '.*'
+                    // InternalRoom.g:22359:2: '.*'
                     {
                     match(input,127,FOLLOW_2); 
 
@@ -60693,14 +60849,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:22374: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:22378:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 )
+            // InternalRoom.g:22379:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1
             {
             pushFollow(FOLLOW_14);
             rule__Documentation__Group__0__Impl();
@@ -60731,21 +60887,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__0__Impl"
-    // InternalRoom.g:22339:1: rule__Documentation__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22386: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:22390:1: ( ( () ) )
+            // InternalRoom.g:22391:1: ( () )
             {
-            // InternalRoom.g:22344:1: ( () )
-            // InternalRoom.g:22345:1: ()
+            // InternalRoom.g:22391:1: ( () )
+            // InternalRoom.g:22392:1: ()
             {
              before(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); 
-            // InternalRoom.g:22346:1: ()
-            // InternalRoom.g:22348:1: 
+            // InternalRoom.g:22393:1: ()
+            // InternalRoom.g:22395:1: 
             {
             }
 
@@ -60768,14 +60924,14 @@ 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:22405: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:22409:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 )
+            // InternalRoom.g:22410:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2
             {
             pushFollow(FOLLOW_117);
             rule__Documentation__Group__1__Impl();
@@ -60806,17 +60962,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__1__Impl"
-    // InternalRoom.g:22370:1: rule__Documentation__Group__1__Impl : ( '[' ) ;
+    // InternalRoom.g:22417: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:22421:1: ( ( '[' ) )
+            // InternalRoom.g:22422:1: ( '[' )
             {
-            // InternalRoom.g:22375:1: ( '[' )
-            // InternalRoom.g:22376:1: '['
+            // InternalRoom.g:22422:1: ( '[' )
+            // InternalRoom.g:22423:1: '['
             {
              before(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); 
             match(input,62,FOLLOW_2); 
@@ -60843,14 +60999,14 @@ 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:22436: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:22440:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 )
+            // InternalRoom.g:22441:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3
             {
             pushFollow(FOLLOW_117);
             rule__Documentation__Group__2__Impl();
@@ -60881,33 +61037,33 @@ 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:22448: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:22452:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) )
+            // InternalRoom.g:22453:1: ( ( rule__Documentation__LinesAssignment_2 )* )
             {
-            // InternalRoom.g:22406:1: ( ( rule__Documentation__LinesAssignment_2 )* )
-            // InternalRoom.g:22407:1: ( rule__Documentation__LinesAssignment_2 )*
+            // InternalRoom.g:22453:1: ( ( rule__Documentation__LinesAssignment_2 )* )
+            // InternalRoom.g:22454:1: ( rule__Documentation__LinesAssignment_2 )*
             {
              before(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); 
-            // InternalRoom.g:22408:1: ( rule__Documentation__LinesAssignment_2 )*
-            loop200:
+            // InternalRoom.g:22455:1: ( rule__Documentation__LinesAssignment_2 )*
+            loop201:
             do {
-                int alt200=2;
-                int LA200_0 = input.LA(1);
+                int alt201=2;
+                int LA201_0 = input.LA(1);
 
-                if ( (LA200_0==RULE_STRING) ) {
-                    alt200=1;
+                if ( (LA201_0==RULE_STRING) ) {
+                    alt201=1;
                 }
 
 
-                switch (alt200) {
+                switch (alt201) {
             	case 1 :
-            	    // InternalRoom.g:22408:2: rule__Documentation__LinesAssignment_2
+            	    // InternalRoom.g:22455:2: rule__Documentation__LinesAssignment_2
             	    {
             	    pushFollow(FOLLOW_84);
             	    rule__Documentation__LinesAssignment_2();
@@ -60919,7 +61075,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop200;
+            	    break loop201;
                 }
             } while (true);
 
@@ -60946,14 +61102,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:22465: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:22469:1: ( rule__Documentation__Group__3__Impl )
+            // InternalRoom.g:22470:2: rule__Documentation__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Documentation__Group__3__Impl();
@@ -60979,17 +61135,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__Group__3__Impl"
-    // InternalRoom.g:22429:1: rule__Documentation__Group__3__Impl : ( ']' ) ;
+    // InternalRoom.g:22476: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:22480:1: ( ( ']' ) )
+            // InternalRoom.g:22481:1: ( ']' )
             {
-            // InternalRoom.g:22434:1: ( ']' )
-            // InternalRoom.g:22435:1: ']'
+            // InternalRoom.g:22481:1: ( ']' )
+            // InternalRoom.g:22482:1: ']'
             {
              before(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); 
             match(input,63,FOLLOW_2); 
@@ -61016,14 +61172,14 @@ 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:22509: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:22513:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 )
+            // InternalRoom.g:22514:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1
             {
             pushFollow(FOLLOW_118);
             rule__BooleanLiteral__Group__0__Impl();
@@ -61054,21 +61210,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BooleanLiteral__Group__0__Impl"
-    // InternalRoom.g:22474:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22521: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:22525:1: ( ( () ) )
+            // InternalRoom.g:22526:1: ( () )
             {
-            // InternalRoom.g:22479:1: ( () )
-            // InternalRoom.g:22480:1: ()
+            // InternalRoom.g:22526:1: ( () )
+            // InternalRoom.g:22527:1: ()
             {
              before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); 
-            // InternalRoom.g:22481:1: ()
-            // InternalRoom.g:22483:1: 
+            // InternalRoom.g:22528:1: ()
+            // InternalRoom.g:22530:1: 
             {
             }
 
@@ -61091,14 +61247,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:22540: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:22544:1: ( rule__BooleanLiteral__Group__1__Impl )
+            // InternalRoom.g:22545:2: rule__BooleanLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Group__1__Impl();
@@ -61124,21 +61280,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:22551: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:22555:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) )
+            // InternalRoom.g:22556:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
             {
-            // InternalRoom.g:22509:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
-            // InternalRoom.g:22510:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalRoom.g:22556:1: ( ( rule__BooleanLiteral__Alternatives_1 ) )
+            // InternalRoom.g:22557: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:22558:1: ( rule__BooleanLiteral__Alternatives_1 )
+            // InternalRoom.g:22558:2: rule__BooleanLiteral__Alternatives_1
             {
             pushFollow(FOLLOW_2);
             rule__BooleanLiteral__Alternatives_1();
@@ -61171,14 +61327,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:22572: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:22576:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 )
+            // InternalRoom.g:22577:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__RealLiteral__Group__0__Impl();
@@ -61209,21 +61365,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__Group__0__Impl"
-    // InternalRoom.g:22537:1: rule__RealLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22584: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:22588:1: ( ( () ) )
+            // InternalRoom.g:22589:1: ( () )
             {
-            // InternalRoom.g:22542:1: ( () )
-            // InternalRoom.g:22543:1: ()
+            // InternalRoom.g:22589:1: ( () )
+            // InternalRoom.g:22590:1: ()
             {
              before(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); 
-            // InternalRoom.g:22544:1: ()
-            // InternalRoom.g:22546:1: 
+            // InternalRoom.g:22591:1: ()
+            // InternalRoom.g:22593:1: 
             {
             }
 
@@ -61246,14 +61402,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:22603: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:22607:1: ( rule__RealLiteral__Group__1__Impl )
+            // InternalRoom.g:22608:2: rule__RealLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__Group__1__Impl();
@@ -61279,21 +61435,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:22614: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:22618:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22619:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22572:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22573:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22619:1: ( ( rule__RealLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22620: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:22621:1: ( rule__RealLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22621:2: rule__RealLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__RealLiteral__ValueAssignment_1();
@@ -61326,14 +61482,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:22635: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:22639:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 )
+            // InternalRoom.g:22640:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__IntLiteral__Group__0__Impl();
@@ -61364,21 +61520,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__Group__0__Impl"
-    // InternalRoom.g:22600:1: rule__IntLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22647: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:22651:1: ( ( () ) )
+            // InternalRoom.g:22652:1: ( () )
             {
-            // InternalRoom.g:22605:1: ( () )
-            // InternalRoom.g:22606:1: ()
+            // InternalRoom.g:22652:1: ( () )
+            // InternalRoom.g:22653:1: ()
             {
              before(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); 
-            // InternalRoom.g:22607:1: ()
-            // InternalRoom.g:22609:1: 
+            // InternalRoom.g:22654:1: ()
+            // InternalRoom.g:22656:1: 
             {
             }
 
@@ -61401,14 +61557,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:22666: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:22670:1: ( rule__IntLiteral__Group__1__Impl )
+            // InternalRoom.g:22671:2: rule__IntLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__Group__1__Impl();
@@ -61434,21 +61590,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:22677: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:22681:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22682:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22635:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22636:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22682:1: ( ( rule__IntLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22683: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:22684:1: ( rule__IntLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22684:2: rule__IntLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__IntLiteral__ValueAssignment_1();
@@ -61481,14 +61637,14 @@ 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:22698: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:22702:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
+            // InternalRoom.g:22703:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
             {
             pushFollow(FOLLOW_106);
             rule__StringLiteral__Group__0__Impl();
@@ -61519,21 +61675,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__Group__0__Impl"
-    // InternalRoom.g:22663:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
+    // InternalRoom.g:22710: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:22714:1: ( ( () ) )
+            // InternalRoom.g:22715:1: ( () )
             {
-            // InternalRoom.g:22668:1: ( () )
-            // InternalRoom.g:22669:1: ()
+            // InternalRoom.g:22715:1: ( () )
+            // InternalRoom.g:22716:1: ()
             {
              before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); 
-            // InternalRoom.g:22670:1: ()
-            // InternalRoom.g:22672:1: 
+            // InternalRoom.g:22717:1: ()
+            // InternalRoom.g:22719:1: 
             {
             }
 
@@ -61556,14 +61712,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:22729: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:22733:1: ( rule__StringLiteral__Group__1__Impl )
+            // InternalRoom.g:22734:2: rule__StringLiteral__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__Group__1__Impl();
@@ -61589,21 +61745,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:22740: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:22744:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) )
+            // InternalRoom.g:22745:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
             {
-            // InternalRoom.g:22698:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
-            // InternalRoom.g:22699:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22745:1: ( ( rule__StringLiteral__ValueAssignment_1 ) )
+            // InternalRoom.g:22746: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:22747:1: ( rule__StringLiteral__ValueAssignment_1 )
+            // InternalRoom.g:22747:2: rule__StringLiteral__ValueAssignment_1
             {
             pushFollow(FOLLOW_2);
             rule__StringLiteral__ValueAssignment_1();
@@ -61636,14 +61792,14 @@ 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:22761: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:22765:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 )
+            // InternalRoom.g:22766:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1
             {
             pushFollow(FOLLOW_119);
             rule__Integer__Group_0__0__Impl();
@@ -61674,29 +61830,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:22773: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:22777:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) )
+            // InternalRoom.g:22778: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:22778:1: ( ( rule__Integer__Alternatives_0_0 )? )
+            // InternalRoom.g:22779: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:22780:1: ( rule__Integer__Alternatives_0_0 )?
+            int alt202=2;
+            int LA202_0 = input.LA(1);
 
-            if ( ((LA201_0>=29 && LA201_0<=30)) ) {
-                alt201=1;
+            if ( ((LA202_0>=29 && LA202_0<=30)) ) {
+                alt202=1;
             }
-            switch (alt201) {
+            switch (alt202) {
                 case 1 :
-                    // InternalRoom.g:22733:2: rule__Integer__Alternatives_0_0
+                    // InternalRoom.g:22780:2: rule__Integer__Alternatives_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Integer__Alternatives_0_0();
@@ -61732,14 +61888,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:22790: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:22794:1: ( rule__Integer__Group_0__1__Impl )
+            // InternalRoom.g:22795:2: rule__Integer__Group_0__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Integer__Group_0__1__Impl();
@@ -61765,17 +61921,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:22801: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:22805:1: ( ( RULE_INT ) )
+            // InternalRoom.g:22806:1: ( RULE_INT )
             {
-            // InternalRoom.g:22759:1: ( RULE_INT )
-            // InternalRoom.g:22760:1: RULE_INT
+            // InternalRoom.g:22806:1: ( RULE_INT )
+            // InternalRoom.g:22807:1: RULE_INT
             {
              before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_0_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -61802,14 +61958,14 @@ 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:22822: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:22826:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 )
+            // InternalRoom.g:22827:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1
             {
             pushFollow(FOLLOW_119);
             rule__Decimal__Group__0__Impl();
@@ -61840,29 +61996,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:22834: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:22838:1: ( ( ( rule__Decimal__Alternatives_0 )? ) )
+            // InternalRoom.g:22839:1: ( ( rule__Decimal__Alternatives_0 )? )
             {
-            // InternalRoom.g:22792:1: ( ( rule__Decimal__Alternatives_0 )? )
-            // InternalRoom.g:22793:1: ( rule__Decimal__Alternatives_0 )?
+            // InternalRoom.g:22839:1: ( ( rule__Decimal__Alternatives_0 )? )
+            // InternalRoom.g:22840: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:22841:1: ( rule__Decimal__Alternatives_0 )?
+            int alt203=2;
+            int LA203_0 = input.LA(1);
 
-            if ( ((LA202_0>=29 && LA202_0<=30)) ) {
-                alt202=1;
+            if ( ((LA203_0>=29 && LA203_0<=30)) ) {
+                alt203=1;
             }
-            switch (alt202) {
+            switch (alt203) {
                 case 1 :
-                    // InternalRoom.g:22794:2: rule__Decimal__Alternatives_0
+                    // InternalRoom.g:22841:2: rule__Decimal__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__Decimal__Alternatives_0();
@@ -61898,14 +62054,14 @@ 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:22851: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:22855:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 )
+            // InternalRoom.g:22856:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2
             {
             pushFollow(FOLLOW_73);
             rule__Decimal__Group__1__Impl();
@@ -61936,17 +62092,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:22863: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:22867:1: ( ( RULE_INT ) )
+            // InternalRoom.g:22868:1: ( RULE_INT )
             {
-            // InternalRoom.g:22821:1: ( RULE_INT )
-            // InternalRoom.g:22822:1: RULE_INT
+            // InternalRoom.g:22868:1: ( RULE_INT )
+            // InternalRoom.g:22869:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -61973,14 +62129,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:22880: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:22884:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 )
+            // InternalRoom.g:22885:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3
             {
             pushFollow(FOLLOW_30);
             rule__Decimal__Group__2__Impl();
@@ -62011,17 +62167,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Decimal__Group__2__Impl"
-    // InternalRoom.g:22845:1: rule__Decimal__Group__2__Impl : ( '.' ) ;
+    // InternalRoom.g:22892: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:22896:1: ( ( '.' ) )
+            // InternalRoom.g:22897:1: ( '.' )
             {
-            // InternalRoom.g:22850:1: ( '.' )
-            // InternalRoom.g:22851:1: '.'
+            // InternalRoom.g:22897:1: ( '.' )
+            // InternalRoom.g:22898:1: '.'
             {
              before(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); 
             match(input,87,FOLLOW_2); 
@@ -62048,14 +62204,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:22911: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:22915:1: ( rule__Decimal__Group__3__Impl )
+            // InternalRoom.g:22916:2: rule__Decimal__Group__3__Impl
             {
             pushFollow(FOLLOW_2);
             rule__Decimal__Group__3__Impl();
@@ -62081,17 +62237,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:22922: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:22926:1: ( ( RULE_INT ) )
+            // InternalRoom.g:22927:1: ( RULE_INT )
             {
-            // InternalRoom.g:22880:1: ( RULE_INT )
-            // InternalRoom.g:22881:1: RULE_INT
+            // InternalRoom.g:22927:1: ( RULE_INT )
+            // InternalRoom.g:22928:1: RULE_INT
             {
              before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62118,14 +62274,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:22947: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:22951:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 )
+            // InternalRoom.g:22952:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1
             {
             pushFollow(FOLLOW_21);
             rule__DecimalExp__Group__0__Impl();
@@ -62156,29 +62312,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:22959: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:22963:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) )
+            // InternalRoom.g:22964:1: ( ( rule__DecimalExp__Alternatives_0 )? )
             {
-            // InternalRoom.g:22917:1: ( ( rule__DecimalExp__Alternatives_0 )? )
-            // InternalRoom.g:22918:1: ( rule__DecimalExp__Alternatives_0 )?
+            // InternalRoom.g:22964:1: ( ( rule__DecimalExp__Alternatives_0 )? )
+            // InternalRoom.g:22965: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:22966:1: ( rule__DecimalExp__Alternatives_0 )?
+            int alt204=2;
+            int LA204_0 = input.LA(1);
 
-            if ( ((LA203_0>=29 && LA203_0<=30)) ) {
-                alt203=1;
+            if ( ((LA204_0>=29 && LA204_0<=30)) ) {
+                alt204=1;
             }
-            switch (alt203) {
+            switch (alt204) {
                 case 1 :
-                    // InternalRoom.g:22919:2: rule__DecimalExp__Alternatives_0
+                    // InternalRoom.g:22966:2: rule__DecimalExp__Alternatives_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_0();
@@ -62214,14 +62370,14 @@ 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:22976: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:22980:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 )
+            // InternalRoom.g:22981:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2
             {
             pushFollow(FOLLOW_73);
             rule__DecimalExp__Group__1__Impl();
@@ -62252,17 +62408,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:22988: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:22992:1: ( ( RULE_INT ) )
+            // InternalRoom.g:22993:1: ( RULE_INT )
             {
-            // InternalRoom.g:22946:1: ( RULE_INT )
-            // InternalRoom.g:22947:1: RULE_INT
+            // InternalRoom.g:22993:1: ( RULE_INT )
+            // InternalRoom.g:22994:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62289,14 +62445,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:23005: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:23009:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 )
+            // InternalRoom.g:23010:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3
             {
             pushFollow(FOLLOW_30);
             rule__DecimalExp__Group__2__Impl();
@@ -62327,17 +62483,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DecimalExp__Group__2__Impl"
-    // InternalRoom.g:22970:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ;
+    // InternalRoom.g:23017: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:23021:1: ( ( '.' ) )
+            // InternalRoom.g:23022:1: ( '.' )
             {
-            // InternalRoom.g:22975:1: ( '.' )
-            // InternalRoom.g:22976:1: '.'
+            // InternalRoom.g:23022:1: ( '.' )
+            // InternalRoom.g:23023:1: '.'
             {
              before(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); 
             match(input,87,FOLLOW_2); 
@@ -62364,14 +62520,14 @@ 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:23036: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:23040:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 )
+            // InternalRoom.g:23041:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4
             {
             pushFollow(FOLLOW_120);
             rule__DecimalExp__Group__3__Impl();
@@ -62402,17 +62558,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:23048: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:23052:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23053:1: ( RULE_INT )
             {
-            // InternalRoom.g:23006:1: ( RULE_INT )
-            // InternalRoom.g:23007:1: RULE_INT
+            // InternalRoom.g:23053:1: ( RULE_INT )
+            // InternalRoom.g:23054:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62439,14 +62595,14 @@ 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:23065: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:23069:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 )
+            // InternalRoom.g:23070:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5
             {
             pushFollow(FOLLOW_119);
             rule__DecimalExp__Group__4__Impl();
@@ -62477,21 +62633,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:23077: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:23081:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) )
+            // InternalRoom.g:23082:1: ( ( rule__DecimalExp__Alternatives_4 ) )
             {
-            // InternalRoom.g:23035:1: ( ( rule__DecimalExp__Alternatives_4 ) )
-            // InternalRoom.g:23036:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalRoom.g:23082:1: ( ( rule__DecimalExp__Alternatives_4 ) )
+            // InternalRoom.g:23083: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:23084:1: ( rule__DecimalExp__Alternatives_4 )
+            // InternalRoom.g:23084:2: rule__DecimalExp__Alternatives_4
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Alternatives_4();
@@ -62524,14 +62680,14 @@ 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:23094: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:23098:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 )
+            // InternalRoom.g:23099:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6
             {
             pushFollow(FOLLOW_119);
             rule__DecimalExp__Group__5__Impl();
@@ -62562,29 +62718,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:23106: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:23110:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) )
+            // InternalRoom.g:23111:1: ( ( rule__DecimalExp__Alternatives_5 )? )
             {
-            // InternalRoom.g:23064:1: ( ( rule__DecimalExp__Alternatives_5 )? )
-            // InternalRoom.g:23065:1: ( rule__DecimalExp__Alternatives_5 )?
+            // InternalRoom.g:23111:1: ( ( rule__DecimalExp__Alternatives_5 )? )
+            // InternalRoom.g:23112: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:23113:1: ( rule__DecimalExp__Alternatives_5 )?
+            int alt205=2;
+            int LA205_0 = input.LA(1);
 
-            if ( ((LA204_0>=29 && LA204_0<=30)) ) {
-                alt204=1;
+            if ( ((LA205_0>=29 && LA205_0<=30)) ) {
+                alt205=1;
             }
-            switch (alt204) {
+            switch (alt205) {
                 case 1 :
-                    // InternalRoom.g:23066:2: rule__DecimalExp__Alternatives_5
+                    // InternalRoom.g:23113:2: rule__DecimalExp__Alternatives_5
                     {
                     pushFollow(FOLLOW_2);
                     rule__DecimalExp__Alternatives_5();
@@ -62620,14 +62776,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:23123: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:23127:1: ( rule__DecimalExp__Group__6__Impl )
+            // InternalRoom.g:23128:2: rule__DecimalExp__Group__6__Impl
             {
             pushFollow(FOLLOW_2);
             rule__DecimalExp__Group__6__Impl();
@@ -62653,17 +62809,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:23134: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:23138:1: ( ( RULE_INT ) )
+            // InternalRoom.g:23139:1: ( RULE_INT )
             {
-            // InternalRoom.g:23092:1: ( RULE_INT )
-            // InternalRoom.g:23093:1: RULE_INT
+            // InternalRoom.g:23139:1: ( RULE_INT )
+            // InternalRoom.g:23140:1: RULE_INT
             {
              before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_6()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -62690,14 +62846,14 @@ 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:23165: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:23169:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 )
+            // InternalRoom.g:23170:2: rule__FQN__Group__0__Impl rule__FQN__Group__1
             {
             pushFollow(FOLLOW_73);
             rule__FQN__Group__0__Impl();
@@ -62728,17 +62884,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:23177: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:23181:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23182:1: ( RULE_ID )
             {
-            // InternalRoom.g:23135:1: ( RULE_ID )
-            // InternalRoom.g:23136:1: RULE_ID
+            // InternalRoom.g:23182:1: ( RULE_ID )
+            // InternalRoom.g:23183:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -62765,14 +62921,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:23194: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:23198:1: ( rule__FQN__Group__1__Impl )
+            // InternalRoom.g:23199:2: rule__FQN__Group__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group__1__Impl();
@@ -62798,33 +62954,33 @@ 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:23205: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:23209:1: ( ( ( rule__FQN__Group_1__0 )* ) )
+            // InternalRoom.g:23210: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:23210:1: ( ( rule__FQN__Group_1__0 )* )
+            // InternalRoom.g:23211:1: ( rule__FQN__Group_1__0 )*
             {
              before(grammarAccess.getFQNAccess().getGroup_1()); 
-            // InternalRoom.g:23165:1: ( rule__FQN__Group_1__0 )*
-            loop205:
+            // InternalRoom.g:23212:1: ( rule__FQN__Group_1__0 )*
+            loop206:
             do {
-                int alt205=2;
-                int LA205_0 = input.LA(1);
+                int alt206=2;
+                int LA206_0 = input.LA(1);
 
-                if ( (LA205_0==87) ) {
-                    alt205=1;
+                if ( (LA206_0==87) ) {
+                    alt206=1;
                 }
 
 
-                switch (alt205) {
+                switch (alt206) {
             	case 1 :
-            	    // InternalRoom.g:23165:2: rule__FQN__Group_1__0
+            	    // InternalRoom.g:23212:2: rule__FQN__Group_1__0
             	    {
             	    pushFollow(FOLLOW_121);
             	    rule__FQN__Group_1__0();
@@ -62836,7 +62992,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             	    break;
 
             	default :
-            	    break loop205;
+            	    break loop206;
                 }
             } while (true);
 
@@ -62863,14 +63019,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:23226: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:23230:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 )
+            // InternalRoom.g:23231:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1
             {
             pushFollow(FOLLOW_3);
             rule__FQN__Group_1__0__Impl();
@@ -62901,17 +63057,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:23238: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:23242:1: ( ( '.' ) )
+            // InternalRoom.g:23243:1: ( '.' )
             {
-            // InternalRoom.g:23196:1: ( '.' )
-            // InternalRoom.g:23197:1: '.'
+            // InternalRoom.g:23243:1: ( '.' )
+            // InternalRoom.g:23244:1: '.'
             {
              before(grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); 
             match(input,87,FOLLOW_2); 
@@ -62938,14 +63094,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:23257: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:23261:1: ( rule__FQN__Group_1__1__Impl )
+            // InternalRoom.g:23262:2: rule__FQN__Group_1__1__Impl
             {
             pushFollow(FOLLOW_2);
             rule__FQN__Group_1__1__Impl();
@@ -62971,17 +63127,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:23268: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:23272:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23273:1: ( RULE_ID )
             {
-            // InternalRoom.g:23226:1: ( RULE_ID )
-            // InternalRoom.g:23227:1: RULE_ID
+            // InternalRoom.g:23273:1: ( RULE_ID )
+            // InternalRoom.g:23274:1: RULE_ID
             {
              before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63008,29 +63164,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:23290: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:23295:1: ( ( rule__ActorClass__UnorderedGroup_0__0 )? )
+            // InternalRoom.g:23296: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:23296:2: ( rule__ActorClass__UnorderedGroup_0__0 )?
+            int alt207=2;
+            int LA207_0 = input.LA(1);
 
-            if ( LA206_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt206=1;
+            if ( LA207_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt207=1;
             }
-            else if ( ( LA206_0 >= 33 && LA206_0 <= 35 || LA206_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt206=1;
+            else if ( ( LA207_0 >= 33 && LA207_0 <= 35 || LA207_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt207=1;
             }
-            switch (alt206) {
+            switch (alt207) {
                 case 1 :
-                    // InternalRoom.g:23249:2: rule__ActorClass__UnorderedGroup_0__0
+                    // InternalRoom.g:23296:2: rule__ActorClass__UnorderedGroup_0__0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__UnorderedGroup_0__0();
@@ -63063,44 +63219,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:23306: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:23311:1: ( ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) ) )
+            // InternalRoom.g:23312: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:23312:3: ( ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) ) )
+            int alt208=2;
+            int LA208_0 = input.LA(1);
 
-            if ( LA207_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt207=1;
+            if ( LA208_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt208=1;
             }
-            else if ( ( LA207_0 >= 33 && LA207_0 <= 35 || LA207_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt207=2;
+            else if ( ( LA208_0 >= 33 && LA208_0 <= 35 || LA208_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt208=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 207, 0, input);
+                    new NoViableAltException("", 208, 0, input);
 
                 throw nvae;
             }
-            switch (alt207) {
+            switch (alt208) {
                 case 1 :
-                    // InternalRoom.g:23267:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
+                    // InternalRoom.g:23314: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:23314:4: ({...}? => ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) ) )
+                    // InternalRoom.g:23315: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:23315:107: ( ( ( rule__ActorClass__AbstractAssignment_0_0 ) ) )
+                    // InternalRoom.g:23316:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0);
@@ -63108,12 +63264,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:23322:6: ( ( rule__ActorClass__AbstractAssignment_0_0 ) )
+                    // InternalRoom.g:23324: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:23325:7: ( rule__ActorClass__AbstractAssignment_0_0 )
+                    // InternalRoom.g:23325:8: rule__ActorClass__AbstractAssignment_0_0
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__AbstractAssignment_0_0();
@@ -63137,16 +63293,16 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:23284:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalRoom.g:23331: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:23331:4: ({...}? => ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) ) )
+                    // InternalRoom.g:23332: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:23332:107: ( ( ( rule__ActorClass__CommTypeAssignment_0_1 ) ) )
+                    // InternalRoom.g:23333:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
                     {
                      
                     	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1);
@@ -63154,12 +63310,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:23339:6: ( ( rule__ActorClass__CommTypeAssignment_0_1 ) )
+                    // InternalRoom.g:23341: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:23342:7: ( rule__ActorClass__CommTypeAssignment_0_1 )
+                    // InternalRoom.g:23342:8: rule__ActorClass__CommTypeAssignment_0_1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__CommTypeAssignment_0_1();
@@ -63206,33 +63362,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:23357: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:23361:1: ( rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )? )
+            // InternalRoom.g:23362:2: rule__ActorClass__UnorderedGroup_0__Impl ( rule__ActorClass__UnorderedGroup_0__1 )?
             {
             pushFollow(FOLLOW_122);
             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:23363:2: ( rule__ActorClass__UnorderedGroup_0__1 )?
+            int alt209=2;
+            int LA209_0 = input.LA(1);
 
-            if ( LA208_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
-                alt208=1;
+            if ( LA209_0 == 130 && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0) ) {
+                alt209=1;
             }
-            else if ( ( LA208_0 >= 33 && LA208_0 <= 35 || LA208_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
-                alt208=1;
+            else if ( ( LA209_0 >= 33 && LA209_0 <= 35 || LA209_0 == 38 ) && getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1) ) {
+                alt209=1;
             }
-            switch (alt208) {
+            switch (alt209) {
                 case 1 :
-                    // InternalRoom.g:23316:2: rule__ActorClass__UnorderedGroup_0__1
+                    // InternalRoom.g:23363:2: rule__ActorClass__UnorderedGroup_0__1
                     {
                     pushFollow(FOLLOW_2);
                     rule__ActorClass__UnorderedGroup_0__1();
@@ -63264,14 +63420,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:23370: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:23374:1: ( rule__ActorClass__UnorderedGroup_0__Impl )
+            // InternalRoom.g:23375:2: rule__ActorClass__UnorderedGroup_0__Impl
             {
             pushFollow(FOLLOW_2);
             rule__ActorClass__UnorderedGroup_0__Impl();
@@ -63297,17 +63453,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__NameAssignment_1"
-    // InternalRoom.g:23339:1: rule__RoomModel__NameAssignment_1 : ( ruleFQN ) ;
+    // InternalRoom.g:23386: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:23390:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23391:1: ( ruleFQN )
             {
-            // InternalRoom.g:23344:1: ( ruleFQN )
-            // InternalRoom.g:23345:1: ruleFQN
+            // InternalRoom.g:23391:1: ( ruleFQN )
+            // InternalRoom.g:23392:1: ruleFQN
             {
              before(grammarAccess.getRoomModelAccess().getNameFQNParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -63338,17 +63494,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__DocuAssignment_2"
-    // InternalRoom.g:23354:1: rule__RoomModel__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23401: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:23405:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23406:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23359:1: ( ruleDocumentation )
-            // InternalRoom.g:23360:1: ruleDocumentation
+            // InternalRoom.g:23406:1: ( ruleDocumentation )
+            // InternalRoom.g:23407:1: ruleDocumentation
             {
              before(grammarAccess.getRoomModelAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63379,17 +63535,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RoomModel__ImportsAssignment_4"
-    // InternalRoom.g:23369:1: rule__RoomModel__ImportsAssignment_4 : ( ruleImport ) ;
+    // InternalRoom.g:23416: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:23420:1: ( ( ruleImport ) )
+            // InternalRoom.g:23421:1: ( ruleImport )
             {
-            // InternalRoom.g:23374:1: ( ruleImport )
-            // InternalRoom.g:23375:1: ruleImport
+            // InternalRoom.g:23421:1: ( ruleImport )
+            // InternalRoom.g:23422:1: ruleImport
             {
              before(grammarAccess.getRoomModelAccess().getImportsImportParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -63420,17 +63576,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:23431: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:23435:1: ( ( rulePrimitiveType ) )
+            // InternalRoom.g:23436:1: ( rulePrimitiveType )
             {
-            // InternalRoom.g:23389:1: ( rulePrimitiveType )
-            // InternalRoom.g:23390:1: rulePrimitiveType
+            // InternalRoom.g:23436:1: ( rulePrimitiveType )
+            // InternalRoom.g:23437:1: rulePrimitiveType
             {
              before(grammarAccess.getRoomModelAccess().getPrimitiveTypesPrimitiveTypeParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -63461,17 +63617,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:23446: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:23450:1: ( ( ruleEnumerationType ) )
+            // InternalRoom.g:23451:1: ( ruleEnumerationType )
             {
-            // InternalRoom.g:23404:1: ( ruleEnumerationType )
-            // InternalRoom.g:23405:1: ruleEnumerationType
+            // InternalRoom.g:23451:1: ( ruleEnumerationType )
+            // InternalRoom.g:23452:1: ruleEnumerationType
             {
              before(grammarAccess.getRoomModelAccess().getEnumerationTypesEnumerationTypeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -63502,17 +63658,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:23461: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:23465:1: ( ( ruleExternalType ) )
+            // InternalRoom.g:23466:1: ( ruleExternalType )
             {
-            // InternalRoom.g:23419:1: ( ruleExternalType )
-            // InternalRoom.g:23420:1: ruleExternalType
+            // InternalRoom.g:23466:1: ( ruleExternalType )
+            // InternalRoom.g:23467:1: ruleExternalType
             {
              before(grammarAccess.getRoomModelAccess().getExternalTypesExternalTypeParserRuleCall_5_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63543,17 +63699,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:23476: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:23480:1: ( ( ruleDataClass ) )
+            // InternalRoom.g:23481:1: ( ruleDataClass )
             {
-            // InternalRoom.g:23434:1: ( ruleDataClass )
-            // InternalRoom.g:23435:1: ruleDataClass
+            // InternalRoom.g:23481:1: ( ruleDataClass )
+            // InternalRoom.g:23482:1: ruleDataClass
             {
              before(grammarAccess.getRoomModelAccess().getDataClassesDataClassParserRuleCall_5_3_0()); 
             pushFollow(FOLLOW_2);
@@ -63584,17 +63740,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:23491: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:23495:1: ( ( ruleGeneralProtocolClass ) )
+            // InternalRoom.g:23496:1: ( ruleGeneralProtocolClass )
             {
-            // InternalRoom.g:23449:1: ( ruleGeneralProtocolClass )
-            // InternalRoom.g:23450:1: ruleGeneralProtocolClass
+            // InternalRoom.g:23496:1: ( ruleGeneralProtocolClass )
+            // InternalRoom.g:23497:1: ruleGeneralProtocolClass
             {
              before(grammarAccess.getRoomModelAccess().getProtocolClassesGeneralProtocolClassParserRuleCall_5_4_0()); 
             pushFollow(FOLLOW_2);
@@ -63625,17 +63781,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:23506: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:23510:1: ( ( ruleActorClass ) )
+            // InternalRoom.g:23511:1: ( ruleActorClass )
             {
-            // InternalRoom.g:23464:1: ( ruleActorClass )
-            // InternalRoom.g:23465:1: ruleActorClass
+            // InternalRoom.g:23511:1: ( ruleActorClass )
+            // InternalRoom.g:23512:1: ruleActorClass
             {
              before(grammarAccess.getRoomModelAccess().getActorClassesActorClassParserRuleCall_5_5_0()); 
             pushFollow(FOLLOW_2);
@@ -63666,17 +63822,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:23521: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:23525:1: ( ( ruleSubSystemClass ) )
+            // InternalRoom.g:23526:1: ( ruleSubSystemClass )
             {
-            // InternalRoom.g:23479:1: ( ruleSubSystemClass )
-            // InternalRoom.g:23480:1: ruleSubSystemClass
+            // InternalRoom.g:23526:1: ( ruleSubSystemClass )
+            // InternalRoom.g:23527:1: ruleSubSystemClass
             {
              before(grammarAccess.getRoomModelAccess().getSubSystemClassesSubSystemClassParserRuleCall_5_6_0()); 
             pushFollow(FOLLOW_2);
@@ -63707,17 +63863,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:23536: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:23540:1: ( ( ruleLogicalSystem ) )
+            // InternalRoom.g:23541:1: ( ruleLogicalSystem )
             {
-            // InternalRoom.g:23494:1: ( ruleLogicalSystem )
-            // InternalRoom.g:23495:1: ruleLogicalSystem
+            // InternalRoom.g:23541:1: ( ruleLogicalSystem )
+            // InternalRoom.g:23542:1: ruleLogicalSystem
             {
              before(grammarAccess.getRoomModelAccess().getSystemsLogicalSystemParserRuleCall_5_7_0()); 
             pushFollow(FOLLOW_2);
@@ -63748,17 +63904,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:23551: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:23555:1: ( ( ruleAnnotationType ) )
+            // InternalRoom.g:23556:1: ( ruleAnnotationType )
             {
-            // InternalRoom.g:23509:1: ( ruleAnnotationType )
-            // InternalRoom.g:23510:1: ruleAnnotationType
+            // InternalRoom.g:23556:1: ( ruleAnnotationType )
+            // InternalRoom.g:23557:1: ruleAnnotationType
             {
              before(grammarAccess.getRoomModelAccess().getAnnotationTypesAnnotationTypeParserRuleCall_5_8_0()); 
             pushFollow(FOLLOW_2);
@@ -63789,17 +63945,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__NameAssignment_0"
-    // InternalRoom.g:23519:1: rule__VarDecl__NameAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:23566: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:23570:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23571:1: ( RULE_ID )
             {
-            // InternalRoom.g:23524:1: ( RULE_ID )
-            // InternalRoom.g:23525:1: RULE_ID
+            // InternalRoom.g:23571:1: ( RULE_ID )
+            // InternalRoom.g:23572:1: RULE_ID
             {
              before(grammarAccess.getVarDeclAccess().getNameIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63826,17 +63982,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__VarDecl__RefTypeAssignment_2"
-    // InternalRoom.g:23534:1: rule__VarDecl__RefTypeAssignment_2 : ( ruleRefableType ) ;
+    // InternalRoom.g:23581: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:23585:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:23586:1: ( ruleRefableType )
             {
-            // InternalRoom.g:23539:1: ( ruleRefableType )
-            // InternalRoom.g:23540:1: ruleRefableType
+            // InternalRoom.g:23586:1: ( ruleRefableType )
+            // InternalRoom.g:23587:1: ruleRefableType
             {
              before(grammarAccess.getVarDeclAccess().getRefTypeRefableTypeParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -63867,21 +64023,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__TypeAssignment_0"
-    // InternalRoom.g:23549:1: rule__RefableType__TypeAssignment_0 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:23596: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:23600:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:23601:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23554:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23555:1: ( ruleFQN )
+            // InternalRoom.g:23601:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23602:1: ( ruleFQN )
             {
              before(grammarAccess.getRefableTypeAccess().getTypeDataTypeCrossReference_0_0()); 
-            // InternalRoom.g:23556:1: ( ruleFQN )
-            // InternalRoom.g:23557:1: ruleFQN
+            // InternalRoom.g:23603:1: ( ruleFQN )
+            // InternalRoom.g:23604:1: ruleFQN
             {
              before(grammarAccess.getRefableTypeAccess().getTypeDataTypeFQNParserRuleCall_0_0_1()); 
             pushFollow(FOLLOW_2);
@@ -63916,21 +64072,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefableType__RefAssignment_1"
-    // InternalRoom.g:23568:1: rule__RefableType__RefAssignment_1 : ( ( 'ref' ) ) ;
+    // InternalRoom.g:23615: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:23619:1: ( ( ( 'ref' ) ) )
+            // InternalRoom.g:23620:1: ( ( 'ref' ) )
             {
-            // InternalRoom.g:23573:1: ( ( 'ref' ) )
-            // InternalRoom.g:23574:1: ( 'ref' )
+            // InternalRoom.g:23620:1: ( ( 'ref' ) )
+            // InternalRoom.g:23621:1: ( 'ref' )
             {
              before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); 
-            // InternalRoom.g:23575:1: ( 'ref' )
-            // InternalRoom.g:23576:1: 'ref'
+            // InternalRoom.g:23622:1: ( 'ref' )
+            // InternalRoom.g:23623:1: 'ref'
             {
              before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); 
             match(input,91,FOLLOW_2); 
@@ -63961,17 +64117,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__NameAssignment_1"
-    // InternalRoom.g:23591:1: rule__PrimitiveType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23638: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:23642:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23643:1: ( RULE_ID )
             {
-            // InternalRoom.g:23596:1: ( RULE_ID )
-            // InternalRoom.g:23597:1: RULE_ID
+            // InternalRoom.g:23643:1: ( RULE_ID )
+            // InternalRoom.g:23644:1: RULE_ID
             {
              before(grammarAccess.getPrimitiveTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -63998,17 +64154,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__TypeAssignment_3"
-    // InternalRoom.g:23606:1: rule__PrimitiveType__TypeAssignment_3 : ( ruleLiteralType ) ;
+    // InternalRoom.g:23653: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:23657:1: ( ( ruleLiteralType ) )
+            // InternalRoom.g:23658:1: ( ruleLiteralType )
             {
-            // InternalRoom.g:23611:1: ( ruleLiteralType )
-            // InternalRoom.g:23612:1: ruleLiteralType
+            // InternalRoom.g:23658:1: ( ruleLiteralType )
+            // InternalRoom.g:23659:1: ruleLiteralType
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTypeLiteralTypeEnumRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -64039,17 +64195,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__TargetNameAssignment_5"
-    // InternalRoom.g:23621:1: rule__PrimitiveType__TargetNameAssignment_5 : ( RULE_STRING ) ;
+    // InternalRoom.g:23668: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:23672:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23673:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23626:1: ( RULE_STRING )
-            // InternalRoom.g:23627:1: RULE_STRING
+            // InternalRoom.g:23673:1: ( RULE_STRING )
+            // InternalRoom.g:23674:1: RULE_STRING
             {
              before(grammarAccess.getPrimitiveTypeAccess().getTargetNameSTRINGTerminalRuleCall_5_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64076,17 +64232,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:23683: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:23687:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23688:1: ( ruleFQN )
             {
-            // InternalRoom.g:23641:1: ( ruleFQN )
-            // InternalRoom.g:23642:1: ruleFQN
+            // InternalRoom.g:23688:1: ( ruleFQN )
+            // InternalRoom.g:23689:1: ruleFQN
             {
              before(grammarAccess.getPrimitiveTypeAccess().getCastNameFQNParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64117,17 +64273,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__DefaultValueLiteralAssignment_8"
-    // InternalRoom.g:23651:1: rule__PrimitiveType__DefaultValueLiteralAssignment_8 : ( RULE_STRING ) ;
+    // InternalRoom.g:23698: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:23702:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23703:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23656:1: ( RULE_STRING )
-            // InternalRoom.g:23657:1: RULE_STRING
+            // InternalRoom.g:23703:1: ( RULE_STRING )
+            // InternalRoom.g:23704:1: RULE_STRING
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_8_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64154,17 +64310,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PrimitiveType__DocuAssignment_9"
-    // InternalRoom.g:23666:1: rule__PrimitiveType__DocuAssignment_9 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23713: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:23717:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23718:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23671:1: ( ruleDocumentation )
-            // InternalRoom.g:23672:1: ruleDocumentation
+            // InternalRoom.g:23718:1: ( ruleDocumentation )
+            // InternalRoom.g:23719:1: ruleDocumentation
             {
              before(grammarAccess.getPrimitiveTypeAccess().getDocuDocumentationParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -64195,17 +64351,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__NameAssignment_1"
-    // InternalRoom.g:23681:1: rule__EnumerationType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23728: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:23732:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23733:1: ( RULE_ID )
             {
-            // InternalRoom.g:23686:1: ( RULE_ID )
-            // InternalRoom.g:23687:1: RULE_ID
+            // InternalRoom.g:23733:1: ( RULE_ID )
+            // InternalRoom.g:23734:1: RULE_ID
             {
              before(grammarAccess.getEnumerationTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64232,17 +64388,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumerationType__DocuAssignment_2"
-    // InternalRoom.g:23696:1: rule__EnumerationType__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23743: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:23747:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23748:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23701:1: ( ruleDocumentation )
-            // InternalRoom.g:23702:1: ruleDocumentation
+            // InternalRoom.g:23748:1: ( ruleDocumentation )
+            // InternalRoom.g:23749:1: ruleDocumentation
             {
              before(grammarAccess.getEnumerationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -64273,21 +64429,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:23758: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:23762:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:23763:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23716:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23717:1: ( ruleFQN )
+            // InternalRoom.g:23763:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23764:1: ( ruleFQN )
             {
              before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeCrossReference_3_1_0()); 
-            // InternalRoom.g:23718:1: ( ruleFQN )
-            // InternalRoom.g:23719:1: ruleFQN
+            // InternalRoom.g:23765:1: ( ruleFQN )
+            // InternalRoom.g:23766:1: ruleFQN
             {
              before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -64322,17 +64478,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:23777: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:23781:1: ( ( ruleEnumLiteral ) )
+            // InternalRoom.g:23782:1: ( ruleEnumLiteral )
             {
-            // InternalRoom.g:23735:1: ( ruleEnumLiteral )
-            // InternalRoom.g:23736:1: ruleEnumLiteral
+            // InternalRoom.g:23782:1: ( ruleEnumLiteral )
+            // InternalRoom.g:23783:1: ruleEnumLiteral
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -64363,17 +64519,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:23792: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:23796:1: ( ( ruleEnumLiteral ) )
+            // InternalRoom.g:23797:1: ( ruleEnumLiteral )
             {
-            // InternalRoom.g:23750:1: ( ruleEnumLiteral )
-            // InternalRoom.g:23751:1: ruleEnumLiteral
+            // InternalRoom.g:23797:1: ( ruleEnumLiteral )
+            // InternalRoom.g:23798:1: ruleEnumLiteral
             {
              before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64404,17 +64560,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumLiteral__NameAssignment_0"
-    // InternalRoom.g:23760:1: rule__EnumLiteral__NameAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:23807: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:23811:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23812:1: ( RULE_ID )
             {
-            // InternalRoom.g:23765:1: ( RULE_ID )
-            // InternalRoom.g:23766:1: RULE_ID
+            // InternalRoom.g:23812:1: ( RULE_ID )
+            // InternalRoom.g:23813:1: RULE_ID
             {
              before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64441,17 +64597,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:23822: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:23826:1: ( ( ruleIntLiteral ) )
+            // InternalRoom.g:23827:1: ( ruleIntLiteral )
             {
-            // InternalRoom.g:23780:1: ( ruleIntLiteral )
-            // InternalRoom.g:23781:1: ruleIntLiteral
+            // InternalRoom.g:23827:1: ( ruleIntLiteral )
+            // InternalRoom.g:23828:1: ruleIntLiteral
             {
              before(grammarAccess.getEnumLiteralAccess().getLiteralIntLiteralParserRuleCall_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64482,17 +64638,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__NameAssignment_1"
-    // InternalRoom.g:23790:1: rule__ExternalType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23837: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:23841:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23842:1: ( RULE_ID )
             {
-            // InternalRoom.g:23795:1: ( RULE_ID )
-            // InternalRoom.g:23796:1: RULE_ID
+            // InternalRoom.g:23842:1: ( RULE_ID )
+            // InternalRoom.g:23843:1: RULE_ID
             {
              before(grammarAccess.getExternalTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64519,17 +64675,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__TargetNameAssignment_3"
-    // InternalRoom.g:23805:1: rule__ExternalType__TargetNameAssignment_3 : ( RULE_STRING ) ;
+    // InternalRoom.g:23852: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:23856:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23857:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23810:1: ( RULE_STRING )
-            // InternalRoom.g:23811:1: RULE_STRING
+            // InternalRoom.g:23857:1: ( RULE_STRING )
+            // InternalRoom.g:23858:1: RULE_STRING
             {
              before(grammarAccess.getExternalTypeAccess().getTargetNameSTRINGTerminalRuleCall_3_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64556,17 +64712,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:23867: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:23871:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:23872:1: ( RULE_STRING )
             {
-            // InternalRoom.g:23825:1: ( RULE_STRING )
-            // InternalRoom.g:23826:1: RULE_STRING
+            // InternalRoom.g:23872:1: ( RULE_STRING )
+            // InternalRoom.g:23873:1: RULE_STRING
             {
              before(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -64593,17 +64749,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalType__DocuAssignment_5"
-    // InternalRoom.g:23835:1: rule__ExternalType__DocuAssignment_5 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23882: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:23886:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23887:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23840:1: ( ruleDocumentation )
-            // InternalRoom.g:23841:1: ruleDocumentation
+            // InternalRoom.g:23887:1: ( ruleDocumentation )
+            // InternalRoom.g:23888:1: ruleDocumentation
             {
              before(grammarAccess.getExternalTypeAccess().getDocuDocumentationParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -64634,17 +64790,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__NameAssignment_1"
-    // InternalRoom.g:23850:1: rule__DataClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:23897: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:23901:1: ( ( RULE_ID ) )
+            // InternalRoom.g:23902:1: ( RULE_ID )
             {
-            // InternalRoom.g:23855:1: ( RULE_ID )
-            // InternalRoom.g:23856:1: RULE_ID
+            // InternalRoom.g:23902:1: ( RULE_ID )
+            // InternalRoom.g:23903:1: RULE_ID
             {
              before(grammarAccess.getDataClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -64671,17 +64827,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__DocuAssignment_2"
-    // InternalRoom.g:23865:1: rule__DataClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:23912: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:23916:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:23917:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:23870:1: ( ruleDocumentation )
-            // InternalRoom.g:23871:1: ruleDocumentation
+            // InternalRoom.g:23917:1: ( ruleDocumentation )
+            // InternalRoom.g:23918:1: ruleDocumentation
             {
              before(grammarAccess.getDataClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -64712,21 +64868,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:23927: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:23931:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:23932:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:23885:1: ( ( ruleFQN ) )
-            // InternalRoom.g:23886:1: ( ruleFQN )
+            // InternalRoom.g:23932:1: ( ( ruleFQN ) )
+            // InternalRoom.g:23933:1: ( ruleFQN )
             {
              before(grammarAccess.getDataClassAccess().getBaseDataClassCrossReference_3_1_0()); 
-            // InternalRoom.g:23887:1: ( ruleFQN )
-            // InternalRoom.g:23888:1: ruleFQN
+            // InternalRoom.g:23934:1: ( ruleFQN )
+            // InternalRoom.g:23935:1: ruleFQN
             {
              before(grammarAccess.getDataClassAccess().getBaseDataClassFQNParserRuleCall_3_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -64761,17 +64917,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DataClass__AnnotationsAssignment_5"
-    // InternalRoom.g:23899:1: rule__DataClass__AnnotationsAssignment_5 : ( ruleAnnotation ) ;
+    // InternalRoom.g:23946: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:23950:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:23951:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:23904:1: ( ruleAnnotation )
-            // InternalRoom.g:23905:1: ruleAnnotation
+            // InternalRoom.g:23951:1: ( ruleAnnotation )
+            // InternalRoom.g:23952:1: ruleAnnotation
             {
              before(grammarAccess.getDataClassAccess().getAnnotationsAnnotationParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -64802,17 +64958,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:23961: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:23965:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:23966:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23919:1: ( ruleDetailCode )
-            // InternalRoom.g:23920:1: ruleDetailCode
+            // InternalRoom.g:23966:1: ( ruleDetailCode )
+            // InternalRoom.g:23967:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode1DetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64843,17 +64999,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:23976: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:23980:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:23981:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23934:1: ( ruleDetailCode )
-            // InternalRoom.g:23935:1: ruleDetailCode
+            // InternalRoom.g:23981:1: ( ruleDetailCode )
+            // InternalRoom.g:23982:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode2DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64884,17 +65040,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:23991: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:23995:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:23996:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:23949:1: ( ruleDetailCode )
-            // InternalRoom.g:23950:1: ruleDetailCode
+            // InternalRoom.g:23996:1: ( ruleDetailCode )
+            // InternalRoom.g:23997:1: ruleDetailCode
             {
              before(grammarAccess.getDataClassAccess().getUserCode3DetailCodeParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -64925,17 +65081,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:24006: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:24010:1: ( ( ruleStandardOperation ) )
+            // InternalRoom.g:24011:1: ( ruleStandardOperation )
             {
-            // InternalRoom.g:23964:1: ( ruleStandardOperation )
-            // InternalRoom.g:23965:1: ruleStandardOperation
+            // InternalRoom.g:24011:1: ( ruleStandardOperation )
+            // InternalRoom.g:24012:1: ruleStandardOperation
             {
              before(grammarAccess.getDataClassAccess().getOperationsStandardOperationParserRuleCall_9_0_0()); 
             pushFollow(FOLLOW_2);
@@ -64966,17 +65122,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:24021: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:24025:1: ( ( ruleClassStructor ) )
+            // InternalRoom.g:24026:1: ( ruleClassStructor )
             {
-            // InternalRoom.g:23979:1: ( ruleClassStructor )
-            // InternalRoom.g:23980:1: ruleClassStructor
+            // InternalRoom.g:24026:1: ( ruleClassStructor )
+            // InternalRoom.g:24027:1: ruleClassStructor
             {
              before(grammarAccess.getDataClassAccess().getStructorsClassStructorParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65007,17 +65163,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:24036: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:24040:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:24041:1: ( ruleAttribute )
             {
-            // InternalRoom.g:23994:1: ( ruleAttribute )
-            // InternalRoom.g:23995:1: ruleAttribute
+            // InternalRoom.g:24041:1: ( ruleAttribute )
+            // InternalRoom.g:24042:1: ruleAttribute
             {
              before(grammarAccess.getDataClassAccess().getAttributesAttributeParserRuleCall_9_2_0()); 
             pushFollow(FOLLOW_2);
@@ -65048,17 +65204,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__NameAssignment_1"
-    // InternalRoom.g:24004:1: rule__Attribute__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24051: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:24055:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24056:1: ( RULE_ID )
             {
-            // InternalRoom.g:24009:1: ( RULE_ID )
-            // InternalRoom.g:24010:1: RULE_ID
+            // InternalRoom.g:24056:1: ( RULE_ID )
+            // InternalRoom.g:24057:1: RULE_ID
             {
              before(grammarAccess.getAttributeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65085,17 +65241,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:24066: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:24070:1: ( ( RULE_INT ) )
+            // InternalRoom.g:24071:1: ( RULE_INT )
             {
-            // InternalRoom.g:24024:1: ( RULE_INT )
-            // InternalRoom.g:24025:1: RULE_INT
+            // InternalRoom.g:24071:1: ( RULE_INT )
+            // InternalRoom.g:24072:1: RULE_INT
             {
              before(grammarAccess.getAttributeAccess().getSizeINTTerminalRuleCall_2_1_0()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -65122,17 +65278,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__TypeAssignment_4"
-    // InternalRoom.g:24034:1: rule__Attribute__TypeAssignment_4 : ( ruleRefableType ) ;
+    // InternalRoom.g:24081: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:24085:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24086:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24039:1: ( ruleRefableType )
-            // InternalRoom.g:24040:1: ruleRefableType
+            // InternalRoom.g:24086:1: ( ruleRefableType )
+            // InternalRoom.g:24087:1: ruleRefableType
             {
              before(grammarAccess.getAttributeAccess().getTypeRefableTypeParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -65163,17 +65319,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:24096: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:24100:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:24101:1: ( RULE_STRING )
             {
-            // InternalRoom.g:24054:1: ( RULE_STRING )
-            // InternalRoom.g:24055:1: RULE_STRING
+            // InternalRoom.g:24101:1: ( RULE_STRING )
+            // InternalRoom.g:24102:1: RULE_STRING
             {
              before(grammarAccess.getAttributeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -65200,17 +65356,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Attribute__DocuAssignment_6"
-    // InternalRoom.g:24064:1: rule__Attribute__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24111: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:24115:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24116:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24069:1: ( ruleDocumentation )
-            // InternalRoom.g:24070:1: ruleDocumentation
+            // InternalRoom.g:24116:1: ( ruleDocumentation )
+            // InternalRoom.g:24117:1: ruleDocumentation
             {
              before(grammarAccess.getAttributeAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -65241,21 +65397,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__OverrideAssignment_0"
-    // InternalRoom.g:24079:1: rule__StandardOperation__OverrideAssignment_0 : ( ( 'override' ) ) ;
+    // InternalRoom.g:24126: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:24130:1: ( ( ( 'override' ) ) )
+            // InternalRoom.g:24131:1: ( ( 'override' ) )
             {
-            // InternalRoom.g:24084:1: ( ( 'override' ) )
-            // InternalRoom.g:24085:1: ( 'override' )
+            // InternalRoom.g:24131:1: ( ( 'override' ) )
+            // InternalRoom.g:24132:1: ( 'override' )
             {
              before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); 
-            // InternalRoom.g:24086:1: ( 'override' )
-            // InternalRoom.g:24087:1: 'override'
+            // InternalRoom.g:24133:1: ( 'override' )
+            // InternalRoom.g:24134:1: 'override'
             {
              before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); 
             match(input,128,FOLLOW_2); 
@@ -65286,17 +65442,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__NameAssignment_2"
-    // InternalRoom.g:24102:1: rule__StandardOperation__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24149: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:24153:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24154:1: ( RULE_ID )
             {
-            // InternalRoom.g:24107:1: ( RULE_ID )
-            // InternalRoom.g:24108:1: RULE_ID
+            // InternalRoom.g:24154:1: ( RULE_ID )
+            // InternalRoom.g:24155:1: RULE_ID
             {
              before(grammarAccess.getStandardOperationAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65323,17 +65479,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:24164: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:24168:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24169:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24122:1: ( ruleVarDecl )
-            // InternalRoom.g:24123:1: ruleVarDecl
+            // InternalRoom.g:24169:1: ( ruleVarDecl )
+            // InternalRoom.g:24170:1: ruleVarDecl
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65364,17 +65520,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:24179: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:24183:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24184:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24137:1: ( ruleVarDecl )
-            // InternalRoom.g:24138:1: ruleVarDecl
+            // InternalRoom.g:24184:1: ( ruleVarDecl )
+            // InternalRoom.g:24185:1: ruleVarDecl
             {
              before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65405,17 +65561,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:24194: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:24198:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24199:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24152:1: ( ruleRefableType )
-            // InternalRoom.g:24153:1: ruleRefableType
+            // InternalRoom.g:24199:1: ( ruleRefableType )
+            // InternalRoom.g:24200:1: ruleRefableType
             {
              before(grammarAccess.getStandardOperationAccess().getReturnTypeRefableTypeParserRuleCall_6_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65446,17 +65602,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__DocuAssignment_7"
-    // InternalRoom.g:24162:1: rule__StandardOperation__DocuAssignment_7 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24209: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:24213:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24214:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24167:1: ( ruleDocumentation )
-            // InternalRoom.g:24168:1: ruleDocumentation
+            // InternalRoom.g:24214:1: ( ruleDocumentation )
+            // InternalRoom.g:24215:1: ruleDocumentation
             {
              before(grammarAccess.getStandardOperationAccess().getDocuDocumentationParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -65487,17 +65643,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StandardOperation__DetailCodeAssignment_8"
-    // InternalRoom.g:24177:1: rule__StandardOperation__DetailCodeAssignment_8 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24224: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:24228:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24229:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24182:1: ( ruleDetailCode )
-            // InternalRoom.g:24183:1: ruleDetailCode
+            // InternalRoom.g:24229:1: ( ruleDetailCode )
+            // InternalRoom.g:24230:1: ruleDetailCode
             {
              before(grammarAccess.getStandardOperationAccess().getDetailCodeDetailCodeParserRuleCall_8_0()); 
             pushFollow(FOLLOW_2);
@@ -65528,17 +65684,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__NameAssignment_1"
-    // InternalRoom.g:24192:1: rule__PortOperation__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24239: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:24243:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24244:1: ( RULE_ID )
             {
-            // InternalRoom.g:24197:1: ( RULE_ID )
-            // InternalRoom.g:24198:1: RULE_ID
+            // InternalRoom.g:24244:1: ( RULE_ID )
+            // InternalRoom.g:24245:1: RULE_ID
             {
              before(grammarAccess.getPortOperationAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65565,17 +65721,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:24254: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:24258:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24259:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24212:1: ( ruleVarDecl )
-            // InternalRoom.g:24213:1: ruleVarDecl
+            // InternalRoom.g:24259:1: ( ruleVarDecl )
+            // InternalRoom.g:24260:1: ruleVarDecl
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65606,17 +65762,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:24269: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:24273:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24274:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24227:1: ( ruleVarDecl )
-            // InternalRoom.g:24228:1: ruleVarDecl
+            // InternalRoom.g:24274:1: ( ruleVarDecl )
+            // InternalRoom.g:24275:1: ruleVarDecl
             {
              before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65647,17 +65803,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:24284: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:24288:1: ( ( ruleRefableType ) )
+            // InternalRoom.g:24289:1: ( ruleRefableType )
             {
-            // InternalRoom.g:24242:1: ( ruleRefableType )
-            // InternalRoom.g:24243:1: ruleRefableType
+            // InternalRoom.g:24289:1: ( ruleRefableType )
+            // InternalRoom.g:24290:1: ruleRefableType
             {
              before(grammarAccess.getPortOperationAccess().getReturnTypeRefableTypeParserRuleCall_5_0_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65688,21 +65844,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:24299: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:24303:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:24304:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24257:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24258:1: ( RULE_ID )
+            // InternalRoom.g:24304:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24305: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:24306:1: ( RULE_ID )
+            // InternalRoom.g:24307:1: RULE_ID
             {
              before(grammarAccess.getPortOperationAccess().getSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65733,17 +65889,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__DocuAssignment_6"
-    // InternalRoom.g:24271:1: rule__PortOperation__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24318: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:24322:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24323:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24276:1: ( ruleDocumentation )
-            // InternalRoom.g:24277:1: ruleDocumentation
+            // InternalRoom.g:24323:1: ( ruleDocumentation )
+            // InternalRoom.g:24324:1: ruleDocumentation
             {
              before(grammarAccess.getPortOperationAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -65774,17 +65930,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortOperation__DetailCodeAssignment_7"
-    // InternalRoom.g:24286:1: rule__PortOperation__DetailCodeAssignment_7 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24333: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:24337:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24338:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24291:1: ( ruleDetailCode )
-            // InternalRoom.g:24292:1: ruleDetailCode
+            // InternalRoom.g:24338:1: ( ruleDetailCode )
+            // InternalRoom.g:24339:1: ruleDetailCode
             {
              before(grammarAccess.getPortOperationAccess().getDetailCodeDetailCodeParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -65815,21 +65971,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:24348: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:24352:1: ( ( ( rule__ClassStructor__NameAlternatives_0_0 ) ) )
+            // InternalRoom.g:24353: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:24353:1: ( ( rule__ClassStructor__NameAlternatives_0_0 ) )
+            // InternalRoom.g:24354: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:24355:1: ( rule__ClassStructor__NameAlternatives_0_0 )
+            // InternalRoom.g:24355:2: rule__ClassStructor__NameAlternatives_0_0
             {
             pushFollow(FOLLOW_2);
             rule__ClassStructor__NameAlternatives_0_0();
@@ -65862,17 +66018,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ClassStructor__DetailCodeAssignment_1"
-    // InternalRoom.g:24317:1: rule__ClassStructor__DetailCodeAssignment_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24364: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:24368:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24369:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24322:1: ( ruleDetailCode )
-            // InternalRoom.g:24323:1: ruleDetailCode
+            // InternalRoom.g:24369:1: ( ruleDetailCode )
+            // InternalRoom.g:24370:1: ruleDetailCode
             {
              before(grammarAccess.getClassStructorAccess().getDetailCodeDetailCodeParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -65903,17 +66059,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__CommTypeAssignment_0"
-    // InternalRoom.g:24332:1: rule__ProtocolClass__CommTypeAssignment_0 : ( ruleCommunicationType ) ;
+    // InternalRoom.g:24379: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:24383:1: ( ( ruleCommunicationType ) )
+            // InternalRoom.g:24384:1: ( ruleCommunicationType )
             {
-            // InternalRoom.g:24337:1: ( ruleCommunicationType )
-            // InternalRoom.g:24338:1: ruleCommunicationType
+            // InternalRoom.g:24384:1: ( ruleCommunicationType )
+            // InternalRoom.g:24385:1: ruleCommunicationType
             {
              before(grammarAccess.getProtocolClassAccess().getCommTypeCommunicationTypeEnumRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -65944,17 +66100,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__NameAssignment_2"
-    // InternalRoom.g:24347:1: rule__ProtocolClass__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24394: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:24398:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24399:1: ( RULE_ID )
             {
-            // InternalRoom.g:24352:1: ( RULE_ID )
-            // InternalRoom.g:24353:1: RULE_ID
+            // InternalRoom.g:24399:1: ( RULE_ID )
+            // InternalRoom.g:24400:1: RULE_ID
             {
              before(grammarAccess.getProtocolClassAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -65981,17 +66137,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__DocuAssignment_3"
-    // InternalRoom.g:24362:1: rule__ProtocolClass__DocuAssignment_3 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24409: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:24413:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24414:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24367:1: ( ruleDocumentation )
-            // InternalRoom.g:24368:1: ruleDocumentation
+            // InternalRoom.g:24414:1: ( ruleDocumentation )
+            // InternalRoom.g:24415:1: ruleDocumentation
             {
              before(grammarAccess.getProtocolClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -66022,21 +66178,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:24424: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:24428:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24429:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24382:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24383:1: ( ruleFQN )
+            // InternalRoom.g:24429:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24430:1: ( ruleFQN )
             {
              before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassCrossReference_4_1_0()); 
-            // InternalRoom.g:24384:1: ( ruleFQN )
-            // InternalRoom.g:24385:1: ruleFQN
+            // InternalRoom.g:24431:1: ( ruleFQN )
+            // InternalRoom.g:24432:1: ruleFQN
             {
              before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassFQNParserRuleCall_4_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -66071,17 +66227,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__AnnotationsAssignment_6"
-    // InternalRoom.g:24396:1: rule__ProtocolClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24443: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:24447:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24448:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24401:1: ( ruleAnnotation )
-            // InternalRoom.g:24402:1: ruleAnnotation
+            // InternalRoom.g:24448:1: ( ruleAnnotation )
+            // InternalRoom.g:24449:1: ruleAnnotation
             {
              before(grammarAccess.getProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -66112,17 +66268,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:24458: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:24462:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24463:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24416:1: ( ruleDetailCode )
-            // InternalRoom.g:24417:1: ruleDetailCode
+            // InternalRoom.g:24463:1: ( ruleDetailCode )
+            // InternalRoom.g:24464:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode1DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66153,17 +66309,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:24473: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:24477:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24478:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24431:1: ( ruleDetailCode )
-            // InternalRoom.g:24432:1: ruleDetailCode
+            // InternalRoom.g:24478:1: ( ruleDetailCode )
+            // InternalRoom.g:24479:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode2DetailCodeParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66194,17 +66350,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:24488: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:24492:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24493:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24446:1: ( ruleDetailCode )
-            // InternalRoom.g:24447:1: ruleDetailCode
+            // InternalRoom.g:24493:1: ( ruleDetailCode )
+            // InternalRoom.g:24494:1: ruleDetailCode
             {
              before(grammarAccess.getProtocolClassAccess().getUserCode3DetailCodeParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66235,17 +66391,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:24503: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:24507:1: ( ( ruleMessage ) )
+            // InternalRoom.g:24508:1: ( ruleMessage )
             {
-            // InternalRoom.g:24461:1: ( ruleMessage )
-            // InternalRoom.g:24462:1: ruleMessage
+            // InternalRoom.g:24508:1: ( ruleMessage )
+            // InternalRoom.g:24509:1: ruleMessage
             {
              before(grammarAccess.getProtocolClassAccess().getIncomingMessagesMessageParserRuleCall_10_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66276,17 +66432,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:24518: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:24522:1: ( ( ruleMessage ) )
+            // InternalRoom.g:24523:1: ( ruleMessage )
             {
-            // InternalRoom.g:24476:1: ( ruleMessage )
-            // InternalRoom.g:24477:1: ruleMessage
+            // InternalRoom.g:24523:1: ( ruleMessage )
+            // InternalRoom.g:24524:1: ruleMessage
             {
              before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesMessageParserRuleCall_11_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66317,17 +66473,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:24533: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:24537:1: ( ( rulePortClass ) )
+            // InternalRoom.g:24538:1: ( rulePortClass )
             {
-            // InternalRoom.g:24491:1: ( rulePortClass )
-            // InternalRoom.g:24492:1: rulePortClass
+            // InternalRoom.g:24538:1: ( rulePortClass )
+            // InternalRoom.g:24539:1: rulePortClass
             {
              before(grammarAccess.getProtocolClassAccess().getRegularPortClassParserRuleCall_12_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66358,17 +66514,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:24548: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:24552:1: ( ( rulePortClass ) )
+            // InternalRoom.g:24553:1: ( rulePortClass )
             {
-            // InternalRoom.g:24506:1: ( rulePortClass )
-            // InternalRoom.g:24507:1: rulePortClass
+            // InternalRoom.g:24553:1: ( rulePortClass )
+            // InternalRoom.g:24554:1: rulePortClass
             {
              before(grammarAccess.getProtocolClassAccess().getConjugatedPortClassParserRuleCall_13_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66399,17 +66555,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolClass__SemanticsAssignment_14"
-    // InternalRoom.g:24516:1: rule__ProtocolClass__SemanticsAssignment_14 : ( ruleProtocolSemantics ) ;
+    // InternalRoom.g:24563: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:24567:1: ( ( ruleProtocolSemantics ) )
+            // InternalRoom.g:24568:1: ( ruleProtocolSemantics )
             {
-            // InternalRoom.g:24521:1: ( ruleProtocolSemantics )
-            // InternalRoom.g:24522:1: ruleProtocolSemantics
+            // InternalRoom.g:24568:1: ( ruleProtocolSemantics )
+            // InternalRoom.g:24569:1: ruleProtocolSemantics
             {
              before(grammarAccess.getProtocolClassAccess().getSemanticsProtocolSemanticsParserRuleCall_14_0()); 
             pushFollow(FOLLOW_2);
@@ -66440,17 +66596,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__NameAssignment_1"
-    // InternalRoom.g:24531:1: rule__CompoundProtocolClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24578: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:24582:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24583:1: ( RULE_ID )
             {
-            // InternalRoom.g:24536:1: ( RULE_ID )
-            // InternalRoom.g:24537:1: RULE_ID
+            // InternalRoom.g:24583:1: ( RULE_ID )
+            // InternalRoom.g:24584:1: RULE_ID
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66477,17 +66633,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__DocuAssignment_2"
-    // InternalRoom.g:24546:1: rule__CompoundProtocolClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24593: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:24597:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24598:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24551:1: ( ruleDocumentation )
-            // InternalRoom.g:24552:1: ruleDocumentation
+            // InternalRoom.g:24598:1: ( ruleDocumentation )
+            // InternalRoom.g:24599:1: ruleDocumentation
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -66518,17 +66674,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__AnnotationsAssignment_4"
-    // InternalRoom.g:24561:1: rule__CompoundProtocolClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24608: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:24612:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24613:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24566:1: ( ruleAnnotation )
-            // InternalRoom.g:24567:1: ruleAnnotation
+            // InternalRoom.g:24613:1: ( ruleAnnotation )
+            // InternalRoom.g:24614:1: ruleAnnotation
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -66559,17 +66715,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CompoundProtocolClass__SubProtocolsAssignment_5"
-    // InternalRoom.g:24576:1: rule__CompoundProtocolClass__SubProtocolsAssignment_5 : ( ruleSubProtocol ) ;
+    // InternalRoom.g:24623: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:24627:1: ( ( ruleSubProtocol ) )
+            // InternalRoom.g:24628:1: ( ruleSubProtocol )
             {
-            // InternalRoom.g:24581:1: ( ruleSubProtocol )
-            // InternalRoom.g:24582:1: ruleSubProtocol
+            // InternalRoom.g:24628:1: ( ruleSubProtocol )
+            // InternalRoom.g:24629:1: ruleSubProtocol
             {
              before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsSubProtocolParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -66600,17 +66756,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__NameAssignment_1"
-    // InternalRoom.g:24591:1: rule__SubProtocol__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:24638: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:24642:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24643:1: ( RULE_ID )
             {
-            // InternalRoom.g:24596:1: ( RULE_ID )
-            // InternalRoom.g:24597:1: RULE_ID
+            // InternalRoom.g:24643:1: ( RULE_ID )
+            // InternalRoom.g:24644:1: RULE_ID
             {
              before(grammarAccess.getSubProtocolAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66637,21 +66793,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubProtocol__ProtocolAssignment_3"
-    // InternalRoom.g:24606:1: rule__SubProtocol__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:24653: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:24657:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24658:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24611:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24612:1: ( ruleFQN )
+            // InternalRoom.g:24658:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24659:1: ( ruleFQN )
             {
              before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:24613:1: ( ruleFQN )
-            // InternalRoom.g:24614:1: ruleFQN
+            // InternalRoom.g:24660:1: ( ruleFQN )
+            // InternalRoom.g:24661:1: ruleFQN
             {
              before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -66686,21 +66842,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__PrivAssignment_0"
-    // InternalRoom.g:24625:1: rule__Message__PrivAssignment_0 : ( ( 'private' ) ) ;
+    // InternalRoom.g:24672: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:24676:1: ( ( ( 'private' ) ) )
+            // InternalRoom.g:24677:1: ( ( 'private' ) )
             {
-            // InternalRoom.g:24630:1: ( ( 'private' ) )
-            // InternalRoom.g:24631:1: ( 'private' )
+            // InternalRoom.g:24677:1: ( ( 'private' ) )
+            // InternalRoom.g:24678:1: ( 'private' )
             {
              before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); 
-            // InternalRoom.g:24632:1: ( 'private' )
-            // InternalRoom.g:24633:1: 'private'
+            // InternalRoom.g:24679:1: ( 'private' )
+            // InternalRoom.g:24680:1: 'private'
             {
              before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); 
             match(input,129,FOLLOW_2); 
@@ -66731,17 +66887,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__NameAssignment_2"
-    // InternalRoom.g:24648:1: rule__Message__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24695: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:24699:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24700:1: ( RULE_ID )
             {
-            // InternalRoom.g:24653:1: ( RULE_ID )
-            // InternalRoom.g:24654:1: RULE_ID
+            // InternalRoom.g:24700:1: ( RULE_ID )
+            // InternalRoom.g:24701:1: RULE_ID
             {
              before(grammarAccess.getMessageAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -66768,17 +66924,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__DataAssignment_4"
-    // InternalRoom.g:24663:1: rule__Message__DataAssignment_4 : ( ruleVarDecl ) ;
+    // InternalRoom.g:24710:1: rule__Message__DataAssignment_4 : ( ruleVarDecl ) ;
     public final void rule__Message__DataAssignment_4() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24667:1: ( ( ruleVarDecl ) )
-            // InternalRoom.g:24668:1: ( ruleVarDecl )
+            // InternalRoom.g:24714:1: ( ( ruleVarDecl ) )
+            // InternalRoom.g:24715:1: ( ruleVarDecl )
             {
-            // InternalRoom.g:24668:1: ( ruleVarDecl )
-            // InternalRoom.g:24669:1: ruleVarDecl
+            // InternalRoom.g:24715:1: ( ruleVarDecl )
+            // InternalRoom.g:24716:1: ruleVarDecl
             {
              before(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -66809,17 +66965,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__AnnotationsAssignment_6"
-    // InternalRoom.g:24678:1: rule__Message__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24725:1: rule__Message__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
     public final void rule__Message__AnnotationsAssignment_6() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24682:1: ( ( ruleAnnotation ) )
-            // InternalRoom.g:24683:1: ( ruleAnnotation )
+            // InternalRoom.g:24729:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24730:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24683:1: ( ruleAnnotation )
-            // InternalRoom.g:24684:1: ruleAnnotation
+            // InternalRoom.g:24730:1: ( ruleAnnotation )
+            // InternalRoom.g:24731:1: ruleAnnotation
             {
              before(grammarAccess.getMessageAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -66850,17 +67006,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Message__DocuAssignment_7"
-    // InternalRoom.g:24693:1: rule__Message__DocuAssignment_7 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24740:1: rule__Message__DocuAssignment_7 : ( ruleDocumentation ) ;
     public final void rule__Message__DocuAssignment_7() throws RecognitionException {
 
         		int stackSize = keepStackSize();
             
         try {
-            // InternalRoom.g:24697:1: ( ( ruleDocumentation ) )
-            // InternalRoom.g:24698:1: ( ruleDocumentation )
+            // InternalRoom.g:24744:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24745:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24698:1: ( ruleDocumentation )
-            // InternalRoom.g:24699:1: ruleDocumentation
+            // InternalRoom.g:24745:1: ( ruleDocumentation )
+            // InternalRoom.g:24746:1: ruleDocumentation
             {
              before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -66891,17 +67047,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__PortClass__UserCodeAssignment_2_1"
-    // InternalRoom.g:24708:1: rule__PortClass__UserCodeAssignment_2_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24755: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:24759:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24760:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24713:1: ( ruleDetailCode )
-            // InternalRoom.g:24714:1: ruleDetailCode
+            // InternalRoom.g:24760:1: ( ruleDetailCode )
+            // InternalRoom.g:24761:1: ruleDetailCode
             {
              before(grammarAccess.getPortClassAccess().getUserCodeDetailCodeParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -66932,17 +67088,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:24770: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:24774:1: ( ( ruleMessageHandler ) )
+            // InternalRoom.g:24775:1: ( ruleMessageHandler )
             {
-            // InternalRoom.g:24728:1: ( ruleMessageHandler )
-            // InternalRoom.g:24729:1: ruleMessageHandler
+            // InternalRoom.g:24775:1: ( ruleMessageHandler )
+            // InternalRoom.g:24776:1: ruleMessageHandler
             {
              before(grammarAccess.getPortClassAccess().getMsgHandlersMessageHandlerParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -66973,17 +67129,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:24785: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:24789:1: ( ( rulePortOperation ) )
+            // InternalRoom.g:24790:1: ( rulePortOperation )
             {
-            // InternalRoom.g:24743:1: ( rulePortOperation )
-            // InternalRoom.g:24744:1: rulePortOperation
+            // InternalRoom.g:24790:1: ( rulePortOperation )
+            // InternalRoom.g:24791:1: rulePortOperation
             {
              before(grammarAccess.getPortClassAccess().getOperationsPortOperationParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67014,17 +67170,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:24800: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:24804:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:24805:1: ( ruleAttribute )
             {
-            // InternalRoom.g:24758:1: ( ruleAttribute )
-            // InternalRoom.g:24759:1: ruleAttribute
+            // InternalRoom.g:24805:1: ( ruleAttribute )
+            // InternalRoom.g:24806:1: ruleAttribute
             {
              before(grammarAccess.getPortClassAccess().getAttributesAttributeParserRuleCall_3_2_0()); 
             pushFollow(FOLLOW_2);
@@ -67055,21 +67211,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__MsgAssignment_2"
-    // InternalRoom.g:24768:1: rule__InMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:24815: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:24819:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:24820:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24773:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24774:1: ( RULE_ID )
+            // InternalRoom.g:24820:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24821:1: ( RULE_ID )
             {
              before(grammarAccess.getInMessageHandlerAccess().getMsgMessageCrossReference_2_0()); 
-            // InternalRoom.g:24775:1: ( RULE_ID )
-            // InternalRoom.g:24776:1: RULE_ID
+            // InternalRoom.g:24822:1: ( RULE_ID )
+            // InternalRoom.g:24823:1: RULE_ID
             {
              before(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67100,17 +67256,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InMessageHandler__DetailCodeAssignment_3"
-    // InternalRoom.g:24787:1: rule__InMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24834: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:24838:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24839:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24792:1: ( ruleDetailCode )
-            // InternalRoom.g:24793:1: ruleDetailCode
+            // InternalRoom.g:24839:1: ( ruleDetailCode )
+            // InternalRoom.g:24840:1: ruleDetailCode
             {
              before(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67141,21 +67297,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__MsgAssignment_2"
-    // InternalRoom.g:24802:1: rule__OutMessageHandler__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:24849: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:24853:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:24854:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:24807:1: ( ( RULE_ID ) )
-            // InternalRoom.g:24808:1: ( RULE_ID )
+            // InternalRoom.g:24854:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24855:1: ( RULE_ID )
             {
              before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageCrossReference_2_0()); 
-            // InternalRoom.g:24809:1: ( RULE_ID )
-            // InternalRoom.g:24810:1: RULE_ID
+            // InternalRoom.g:24856:1: ( RULE_ID )
+            // InternalRoom.g:24857:1: RULE_ID
             {
              before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67186,17 +67342,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutMessageHandler__DetailCodeAssignment_3"
-    // InternalRoom.g:24821:1: rule__OutMessageHandler__DetailCodeAssignment_3 : ( ruleDetailCode ) ;
+    // InternalRoom.g:24868: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:24872:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:24873:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24826:1: ( ruleDetailCode )
-            // InternalRoom.g:24827:1: ruleDetailCode
+            // InternalRoom.g:24873:1: ( ruleDetailCode )
+            // InternalRoom.g:24874:1: ruleDetailCode
             {
              before(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67227,21 +67383,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:24883: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:24887:1: ( ( ( 'abstract' ) ) )
+            // InternalRoom.g:24888:1: ( ( 'abstract' ) )
             {
-            // InternalRoom.g:24841:1: ( ( 'abstract' ) )
-            // InternalRoom.g:24842:1: ( 'abstract' )
+            // InternalRoom.g:24888:1: ( ( 'abstract' ) )
+            // InternalRoom.g:24889:1: ( 'abstract' )
             {
              before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); 
-            // InternalRoom.g:24843:1: ( 'abstract' )
-            // InternalRoom.g:24844:1: 'abstract'
+            // InternalRoom.g:24890:1: ( 'abstract' )
+            // InternalRoom.g:24891:1: 'abstract'
             {
              before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); 
             match(input,130,FOLLOW_2); 
@@ -67272,17 +67428,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:24906: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:24910:1: ( ( ruleComponentCommunicationType ) )
+            // InternalRoom.g:24911:1: ( ruleComponentCommunicationType )
             {
-            // InternalRoom.g:24864:1: ( ruleComponentCommunicationType )
-            // InternalRoom.g:24865:1: ruleComponentCommunicationType
+            // InternalRoom.g:24911:1: ( ruleComponentCommunicationType )
+            // InternalRoom.g:24912:1: ruleComponentCommunicationType
             {
              before(grammarAccess.getActorClassAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67313,17 +67469,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__NameAssignment_2"
-    // InternalRoom.g:24874:1: rule__ActorClass__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:24921: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:24925:1: ( ( RULE_ID ) )
+            // InternalRoom.g:24926:1: ( RULE_ID )
             {
-            // InternalRoom.g:24879:1: ( RULE_ID )
-            // InternalRoom.g:24880:1: RULE_ID
+            // InternalRoom.g:24926:1: ( RULE_ID )
+            // InternalRoom.g:24927:1: RULE_ID
             {
              before(grammarAccess.getActorClassAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -67350,17 +67506,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__DocuAssignment_3"
-    // InternalRoom.g:24889:1: rule__ActorClass__DocuAssignment_3 : ( ruleDocumentation ) ;
+    // InternalRoom.g:24936: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:24940:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:24941:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24894:1: ( ruleDocumentation )
-            // InternalRoom.g:24895:1: ruleDocumentation
+            // InternalRoom.g:24941:1: ( ruleDocumentation )
+            // InternalRoom.g:24942:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getDocuDocumentationParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67391,21 +67547,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:24951: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:24955:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:24956:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:24909:1: ( ( ruleFQN ) )
-            // InternalRoom.g:24910:1: ( ruleFQN )
+            // InternalRoom.g:24956:1: ( ( ruleFQN ) )
+            // InternalRoom.g:24957:1: ( ruleFQN )
             {
              before(grammarAccess.getActorClassAccess().getBaseActorClassCrossReference_4_1_0()); 
-            // InternalRoom.g:24911:1: ( ruleFQN )
-            // InternalRoom.g:24912:1: ruleFQN
+            // InternalRoom.g:24958:1: ( ruleFQN )
+            // InternalRoom.g:24959:1: ruleFQN
             {
              before(grammarAccess.getActorClassAccess().getBaseActorClassFQNParserRuleCall_4_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -67440,17 +67596,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorClass__AnnotationsAssignment_6"
-    // InternalRoom.g:24923:1: rule__ActorClass__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:24970: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:24974:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:24975:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:24928:1: ( ruleAnnotation )
-            // InternalRoom.g:24929:1: ruleAnnotation
+            // InternalRoom.g:24975:1: ( ruleAnnotation )
+            // InternalRoom.g:24976:1: ruleAnnotation
             {
              before(grammarAccess.getActorClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -67481,17 +67637,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:24985: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:24989:1: ( ( ruleSPP ) )
+            // InternalRoom.g:24990:1: ( ruleSPP )
             {
-            // InternalRoom.g:24943:1: ( ruleSPP )
-            // InternalRoom.g:24944:1: ruleSPP
+            // InternalRoom.g:24990:1: ( ruleSPP )
+            // InternalRoom.g:24991:1: ruleSPP
             {
              before(grammarAccess.getActorClassAccess().getServiceProvisionPointsSPPParserRuleCall_7_2_0_0()); 
             pushFollow(FOLLOW_2);
@@ -67522,17 +67678,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:25000: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:25004:1: ( ( rulePort ) )
+            // InternalRoom.g:25005:1: ( rulePort )
             {
-            // InternalRoom.g:24958:1: ( rulePort )
-            // InternalRoom.g:24959:1: rulePort
+            // InternalRoom.g:25005:1: ( rulePort )
+            // InternalRoom.g:25006:1: rulePort
             {
              before(grammarAccess.getActorClassAccess().getInterfacePortsPortParserRuleCall_7_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67563,17 +67719,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:25015: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:25019:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25020:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:24973:1: ( ruleDocumentation )
-            // InternalRoom.g:24974:1: ruleDocumentation
+            // InternalRoom.g:25020:1: ( ruleDocumentation )
+            // InternalRoom.g:25021:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getStructureDocuDocumentationParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67604,17 +67760,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:25030: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:25034:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25035:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:24988:1: ( ruleDetailCode )
-            // InternalRoom.g:24989:1: ruleDetailCode
+            // InternalRoom.g:25035:1: ( ruleDetailCode )
+            // InternalRoom.g:25036:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode1DetailCodeParserRuleCall_8_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67645,17 +67801,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:25045: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:25049:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25050:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25003:1: ( ruleDetailCode )
-            // InternalRoom.g:25004:1: ruleDetailCode
+            // InternalRoom.g:25050:1: ( ruleDetailCode )
+            // InternalRoom.g:25051:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode2DetailCodeParserRuleCall_8_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67686,17 +67842,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:25060: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:25064:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25065:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25018:1: ( ruleDetailCode )
-            // InternalRoom.g:25019:1: ruleDetailCode
+            // InternalRoom.g:25065:1: ( ruleDetailCode )
+            // InternalRoom.g:25066:1: ruleDetailCode
             {
              before(grammarAccess.getActorClassAccess().getUserCode3DetailCodeParserRuleCall_8_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67727,17 +67883,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:25075: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:25079:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25080:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25033:1: ( ruleLayerConnection )
-            // InternalRoom.g:25034:1: ruleLayerConnection
+            // InternalRoom.g:25080:1: ( ruleLayerConnection )
+            // InternalRoom.g:25081:1: ruleLayerConnection
             {
              before(grammarAccess.getActorClassAccess().getConnectionsLayerConnectionParserRuleCall_8_6_0_0()); 
             pushFollow(FOLLOW_2);
@@ -67768,17 +67924,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:25090: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:25094:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25095:1: ( ruleBinding )
             {
-            // InternalRoom.g:25048:1: ( ruleBinding )
-            // InternalRoom.g:25049:1: ruleBinding
+            // InternalRoom.g:25095:1: ( ruleBinding )
+            // InternalRoom.g:25096:1: ruleBinding
             {
              before(grammarAccess.getActorClassAccess().getBindingsBindingParserRuleCall_8_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -67809,17 +67965,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:25105: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:25109:1: ( ( ruleServiceImplementation ) )
+            // InternalRoom.g:25110:1: ( ruleServiceImplementation )
             {
-            // InternalRoom.g:25063:1: ( ruleServiceImplementation )
-            // InternalRoom.g:25064:1: ruleServiceImplementation
+            // InternalRoom.g:25110:1: ( ruleServiceImplementation )
+            // InternalRoom.g:25111:1: ruleServiceImplementation
             {
              before(grammarAccess.getActorClassAccess().getServiceImplementationsServiceImplementationParserRuleCall_8_6_2_0()); 
             pushFollow(FOLLOW_2);
@@ -67850,17 +68006,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:25120: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:25124:1: ( ( ruleAttribute ) )
+            // InternalRoom.g:25125:1: ( ruleAttribute )
             {
-            // InternalRoom.g:25078:1: ( ruleAttribute )
-            // InternalRoom.g:25079:1: ruleAttribute
+            // InternalRoom.g:25125:1: ( ruleAttribute )
+            // InternalRoom.g:25126:1: ruleAttribute
             {
              before(grammarAccess.getActorClassAccess().getAttributesAttributeParserRuleCall_8_6_3_0()); 
             pushFollow(FOLLOW_2);
@@ -67891,17 +68047,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:25135: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:25139:1: ( ( ruleActorRef ) )
+            // InternalRoom.g:25140:1: ( ruleActorRef )
             {
-            // InternalRoom.g:25093:1: ( ruleActorRef )
-            // InternalRoom.g:25094:1: ruleActorRef
+            // InternalRoom.g:25140:1: ( ruleActorRef )
+            // InternalRoom.g:25141:1: ruleActorRef
             {
              before(grammarAccess.getActorClassAccess().getActorRefsActorRefParserRuleCall_8_6_4_0()); 
             pushFollow(FOLLOW_2);
@@ -67932,17 +68088,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:25150: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:25154:1: ( ( ruleSAP ) )
+            // InternalRoom.g:25155:1: ( ruleSAP )
             {
-            // InternalRoom.g:25108:1: ( ruleSAP )
-            // InternalRoom.g:25109:1: ruleSAP
+            // InternalRoom.g:25155:1: ( ruleSAP )
+            // InternalRoom.g:25156:1: ruleSAP
             {
              before(grammarAccess.getActorClassAccess().getServiceAccessPointsSAPParserRuleCall_8_6_5_0()); 
             pushFollow(FOLLOW_2);
@@ -67973,17 +68129,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:25165: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:25169:1: ( ( rulePort ) )
+            // InternalRoom.g:25170:1: ( rulePort )
             {
-            // InternalRoom.g:25123:1: ( rulePort )
-            // InternalRoom.g:25124:1: rulePort
+            // InternalRoom.g:25170:1: ( rulePort )
+            // InternalRoom.g:25171:1: rulePort
             {
              before(grammarAccess.getActorClassAccess().getInternalPortsPortParserRuleCall_8_6_6_0()); 
             pushFollow(FOLLOW_2);
@@ -68014,17 +68170,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:25180: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:25184:1: ( ( ruleExternalPort ) )
+            // InternalRoom.g:25185:1: ( ruleExternalPort )
             {
-            // InternalRoom.g:25138:1: ( ruleExternalPort )
-            // InternalRoom.g:25139:1: ruleExternalPort
+            // InternalRoom.g:25185:1: ( ruleExternalPort )
+            // InternalRoom.g:25186:1: ruleExternalPort
             {
              before(grammarAccess.getActorClassAccess().getExternalPortsExternalPortParserRuleCall_8_6_7_0()); 
             pushFollow(FOLLOW_2);
@@ -68055,17 +68211,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:25195: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:25199:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25200:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25153:1: ( ruleDocumentation )
-            // InternalRoom.g:25154:1: ruleDocumentation
+            // InternalRoom.g:25200:1: ( ruleDocumentation )
+            // InternalRoom.g:25201:1: ruleDocumentation
             {
              before(grammarAccess.getActorClassAccess().getBehaviorDocuDocumentationParserRuleCall_9_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68096,17 +68252,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:25210: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:25214:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25215:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25168:1: ( ruleAnnotation )
-            // InternalRoom.g:25169:1: ruleAnnotation
+            // InternalRoom.g:25215:1: ( ruleAnnotation )
+            // InternalRoom.g:25216:1: ruleAnnotation
             {
              before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAnnotationParserRuleCall_9_3_0()); 
             pushFollow(FOLLOW_2);
@@ -68137,17 +68293,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:25225: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:25229:1: ( ( ruleStandardOperation ) )
+            // InternalRoom.g:25230:1: ( ruleStandardOperation )
             {
-            // InternalRoom.g:25183:1: ( ruleStandardOperation )
-            // InternalRoom.g:25184:1: ruleStandardOperation
+            // InternalRoom.g:25230:1: ( ruleStandardOperation )
+            // InternalRoom.g:25231:1: ruleStandardOperation
             {
              before(grammarAccess.getActorClassAccess().getOperationsStandardOperationParserRuleCall_9_4_0_0()); 
             pushFollow(FOLLOW_2);
@@ -68178,17 +68334,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:25240: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:25244:1: ( ( ruleClassStructor ) )
+            // InternalRoom.g:25245:1: ( ruleClassStructor )
             {
-            // InternalRoom.g:25198:1: ( ruleClassStructor )
-            // InternalRoom.g:25199:1: ruleClassStructor
+            // InternalRoom.g:25245:1: ( ruleClassStructor )
+            // InternalRoom.g:25246:1: ruleClassStructor
             {
              before(grammarAccess.getActorClassAccess().getStructorsClassStructorParserRuleCall_9_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68219,17 +68375,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:25255: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:25259:1: ( ( ruleStateMachine ) )
+            // InternalRoom.g:25260:1: ( ruleStateMachine )
             {
-            // InternalRoom.g:25213:1: ( ruleStateMachine )
-            // InternalRoom.g:25214:1: ruleStateMachine
+            // InternalRoom.g:25260:1: ( ruleStateMachine )
+            // InternalRoom.g:25261:1: ruleStateMachine
             {
              before(grammarAccess.getActorClassAccess().getStateMachineStateMachineParserRuleCall_9_5_0()); 
             pushFollow(FOLLOW_2);
@@ -68260,21 +68416,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__ConjugatedAssignment_0"
-    // InternalRoom.g:25223:1: rule__Port__ConjugatedAssignment_0 : ( ( 'conjugated' ) ) ;
+    // InternalRoom.g:25270: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:25274:1: ( ( ( 'conjugated' ) ) )
+            // InternalRoom.g:25275:1: ( ( 'conjugated' ) )
             {
-            // InternalRoom.g:25228:1: ( ( 'conjugated' ) )
-            // InternalRoom.g:25229:1: ( 'conjugated' )
+            // InternalRoom.g:25275:1: ( ( 'conjugated' ) )
+            // InternalRoom.g:25276:1: ( 'conjugated' )
             {
              before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); 
-            // InternalRoom.g:25230:1: ( 'conjugated' )
-            // InternalRoom.g:25231:1: 'conjugated'
+            // InternalRoom.g:25277:1: ( 'conjugated' )
+            // InternalRoom.g:25278:1: 'conjugated'
             {
              before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); 
             match(input,70,FOLLOW_2); 
@@ -68305,17 +68461,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__NameAssignment_2"
-    // InternalRoom.g:25246:1: rule__Port__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:25293: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:25297:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25298:1: ( RULE_ID )
             {
-            // InternalRoom.g:25251:1: ( RULE_ID )
-            // InternalRoom.g:25252:1: RULE_ID
+            // InternalRoom.g:25298:1: ( RULE_ID )
+            // InternalRoom.g:25299:1: RULE_ID
             {
              before(grammarAccess.getPortAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68342,17 +68498,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__MultiplicityAssignment_3"
-    // InternalRoom.g:25261:1: rule__Port__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
+    // InternalRoom.g:25308: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:25312:1: ( ( ruleMULTIPLICITY ) )
+            // InternalRoom.g:25313:1: ( ruleMULTIPLICITY )
             {
-            // InternalRoom.g:25266:1: ( ruleMULTIPLICITY )
-            // InternalRoom.g:25267:1: ruleMULTIPLICITY
+            // InternalRoom.g:25313:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:25314:1: ruleMULTIPLICITY
             {
              before(grammarAccess.getPortAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -68383,21 +68539,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__ProtocolAssignment_5"
-    // InternalRoom.g:25276:1: rule__Port__ProtocolAssignment_5 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25323: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:25327:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25328:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25281:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25282:1: ( ruleFQN )
+            // InternalRoom.g:25328:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25329:1: ( ruleFQN )
             {
              before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassCrossReference_5_0()); 
-            // InternalRoom.g:25283:1: ( ruleFQN )
-            // InternalRoom.g:25284:1: ruleFQN
+            // InternalRoom.g:25330:1: ( ruleFQN )
+            // InternalRoom.g:25331:1: ruleFQN
             {
              before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68432,17 +68588,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__AnnotationsAssignment_6"
-    // InternalRoom.g:25295:1: rule__Port__AnnotationsAssignment_6 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25342: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:25346:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25347:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25300:1: ( ruleAnnotation )
-            // InternalRoom.g:25301:1: ruleAnnotation
+            // InternalRoom.g:25347:1: ( ruleAnnotation )
+            // InternalRoom.g:25348:1: ruleAnnotation
             {
              before(grammarAccess.getPortAccess().getAnnotationsAnnotationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -68473,17 +68629,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Port__DocuAssignment_7"
-    // InternalRoom.g:25310:1: rule__Port__DocuAssignment_7 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25357: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:25361:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25362:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25315:1: ( ruleDocumentation )
-            // InternalRoom.g:25316:1: ruleDocumentation
+            // InternalRoom.g:25362:1: ( ruleDocumentation )
+            // InternalRoom.g:25363:1: ruleDocumentation
             {
              before(grammarAccess.getPortAccess().getDocuDocumentationParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -68514,21 +68670,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExternalPort__InterfacePortAssignment_2"
-    // InternalRoom.g:25325:1: rule__ExternalPort__InterfacePortAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25372: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:25376:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25377:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25330:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25331:1: ( RULE_ID )
+            // InternalRoom.g:25377:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25378:1: ( RULE_ID )
             {
              before(grammarAccess.getExternalPortAccess().getInterfacePortPortCrossReference_2_0()); 
-            // InternalRoom.g:25332:1: ( RULE_ID )
-            // InternalRoom.g:25333:1: RULE_ID
+            // InternalRoom.g:25379:1: ( RULE_ID )
+            // InternalRoom.g:25380:1: RULE_ID
             {
              before(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68559,17 +68715,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__NameAssignment_1"
-    // InternalRoom.g:25344:1: rule__SAP__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25391: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:25395:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25396:1: ( RULE_ID )
             {
-            // InternalRoom.g:25349:1: ( RULE_ID )
-            // InternalRoom.g:25350:1: RULE_ID
+            // InternalRoom.g:25396:1: ( RULE_ID )
+            // InternalRoom.g:25397:1: RULE_ID
             {
              before(grammarAccess.getSAPAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68596,21 +68752,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SAP__ProtocolAssignment_3"
-    // InternalRoom.g:25359:1: rule__SAP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25406: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:25410:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25411:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25364:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25365:1: ( ruleFQN )
+            // InternalRoom.g:25411:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25412:1: ( ruleFQN )
             {
              before(grammarAccess.getSAPAccess().getProtocolProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:25366:1: ( ruleFQN )
-            // InternalRoom.g:25367:1: ruleFQN
+            // InternalRoom.g:25413:1: ( ruleFQN )
+            // InternalRoom.g:25414:1: ruleFQN
             {
              before(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68645,17 +68801,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__NameAssignment_1"
-    // InternalRoom.g:25378:1: rule__SPP__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25425: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:25429:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25430:1: ( RULE_ID )
             {
-            // InternalRoom.g:25383:1: ( RULE_ID )
-            // InternalRoom.g:25384:1: RULE_ID
+            // InternalRoom.g:25430:1: ( RULE_ID )
+            // InternalRoom.g:25431:1: RULE_ID
             {
              before(grammarAccess.getSPPAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68682,21 +68838,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPP__ProtocolAssignment_3"
-    // InternalRoom.g:25393:1: rule__SPP__ProtocolAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25440: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:25444:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25445:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25398:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25399:1: ( ruleFQN )
+            // InternalRoom.g:25445:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25446:1: ( ruleFQN )
             {
              before(grammarAccess.getSPPAccess().getProtocolProtocolClassCrossReference_3_0()); 
-            // InternalRoom.g:25400:1: ( ruleFQN )
-            // InternalRoom.g:25401:1: ruleFQN
+            // InternalRoom.g:25447:1: ( ruleFQN )
+            // InternalRoom.g:25448:1: ruleFQN
             {
              before(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -68731,21 +68887,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ServiceImplementation__SppAssignment_2"
-    // InternalRoom.g:25412:1: rule__ServiceImplementation__SppAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25459: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:25463:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25464:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25417:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25418:1: ( RULE_ID )
+            // InternalRoom.g:25464:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25465:1: ( RULE_ID )
             {
              before(grammarAccess.getServiceImplementationAccess().getSppSPPCrossReference_2_0()); 
-            // InternalRoom.g:25419:1: ( RULE_ID )
-            // InternalRoom.g:25420:1: RULE_ID
+            // InternalRoom.g:25466:1: ( RULE_ID )
+            // InternalRoom.g:25467:1: RULE_ID
             {
              before(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68776,17 +68932,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__NameAssignment_1"
-    // InternalRoom.g:25431:1: rule__LogicalSystem__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25478: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:25482:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25483:1: ( RULE_ID )
             {
-            // InternalRoom.g:25436:1: ( RULE_ID )
-            // InternalRoom.g:25437:1: RULE_ID
+            // InternalRoom.g:25483:1: ( RULE_ID )
+            // InternalRoom.g:25484:1: RULE_ID
             {
              before(grammarAccess.getLogicalSystemAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -68813,17 +68969,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__DocuAssignment_2"
-    // InternalRoom.g:25446:1: rule__LogicalSystem__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25493: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:25497:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25498:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25451:1: ( ruleDocumentation )
-            // InternalRoom.g:25452:1: ruleDocumentation
+            // InternalRoom.g:25498:1: ( ruleDocumentation )
+            // InternalRoom.g:25499:1: ruleDocumentation
             {
              before(grammarAccess.getLogicalSystemAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -68854,17 +69010,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalSystem__AnnotationsAssignment_4"
-    // InternalRoom.g:25461:1: rule__LogicalSystem__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25508: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:25512:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25513:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25466:1: ( ruleAnnotation )
-            // InternalRoom.g:25467:1: ruleAnnotation
+            // InternalRoom.g:25513:1: ( ruleAnnotation )
+            // InternalRoom.g:25514:1: ruleAnnotation
             {
              before(grammarAccess.getLogicalSystemAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -68895,17 +69051,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:25523: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:25527:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25528:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25481:1: ( ruleLayerConnection )
-            // InternalRoom.g:25482:1: ruleLayerConnection
+            // InternalRoom.g:25528:1: ( ruleLayerConnection )
+            // InternalRoom.g:25529:1: ruleLayerConnection
             {
              before(grammarAccess.getLogicalSystemAccess().getConnectionsLayerConnectionParserRuleCall_5_0_0()); 
             pushFollow(FOLLOW_2);
@@ -68936,17 +69092,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:25538: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:25542:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25543:1: ( ruleBinding )
             {
-            // InternalRoom.g:25496:1: ( ruleBinding )
-            // InternalRoom.g:25497:1: ruleBinding
+            // InternalRoom.g:25543:1: ( ruleBinding )
+            // InternalRoom.g:25544:1: ruleBinding
             {
              before(grammarAccess.getLogicalSystemAccess().getBindingsBindingParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -68977,17 +69133,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:25553: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:25557:1: ( ( ruleSubSystemRef ) )
+            // InternalRoom.g:25558:1: ( ruleSubSystemRef )
             {
-            // InternalRoom.g:25511:1: ( ruleSubSystemRef )
-            // InternalRoom.g:25512:1: ruleSubSystemRef
+            // InternalRoom.g:25558:1: ( ruleSubSystemRef )
+            // InternalRoom.g:25559:1: ruleSubSystemRef
             {
              before(grammarAccess.getLogicalSystemAccess().getSubSystemsSubSystemRefParserRuleCall_5_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69018,17 +69174,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__NameAssignment_1"
-    // InternalRoom.g:25521:1: rule__SubSystemRef__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25568: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:25572:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25573:1: ( RULE_ID )
             {
-            // InternalRoom.g:25526:1: ( RULE_ID )
-            // InternalRoom.g:25527:1: RULE_ID
+            // InternalRoom.g:25573:1: ( RULE_ID )
+            // InternalRoom.g:25574:1: RULE_ID
             {
              before(grammarAccess.getSubSystemRefAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69055,21 +69211,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__TypeAssignment_3"
-    // InternalRoom.g:25536:1: rule__SubSystemRef__TypeAssignment_3 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:25583: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:25587:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:25588:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:25541:1: ( ( ruleFQN ) )
-            // InternalRoom.g:25542:1: ( ruleFQN )
+            // InternalRoom.g:25588:1: ( ( ruleFQN ) )
+            // InternalRoom.g:25589:1: ( ruleFQN )
             {
              before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassCrossReference_3_0()); 
-            // InternalRoom.g:25543:1: ( ruleFQN )
-            // InternalRoom.g:25544:1: ruleFQN
+            // InternalRoom.g:25590:1: ( ruleFQN )
+            // InternalRoom.g:25591:1: ruleFQN
             {
              before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassFQNParserRuleCall_3_0_1()); 
             pushFollow(FOLLOW_2);
@@ -69104,17 +69260,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemRef__DocuAssignment_4"
-    // InternalRoom.g:25555:1: rule__SubSystemRef__DocuAssignment_4 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25602: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:25606:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25607:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25560:1: ( ruleDocumentation )
-            // InternalRoom.g:25561:1: ruleDocumentation
+            // InternalRoom.g:25607:1: ( ruleDocumentation )
+            // InternalRoom.g:25608:1: ruleDocumentation
             {
              before(grammarAccess.getSubSystemRefAccess().getDocuDocumentationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69145,17 +69301,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__NameAssignment_1"
-    // InternalRoom.g:25570:1: rule__SubSystemClass__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25617: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:25621:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25622:1: ( RULE_ID )
             {
-            // InternalRoom.g:25575:1: ( RULE_ID )
-            // InternalRoom.g:25576:1: RULE_ID
+            // InternalRoom.g:25622:1: ( RULE_ID )
+            // InternalRoom.g:25623:1: RULE_ID
             {
              before(grammarAccess.getSubSystemClassAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69182,17 +69338,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__DocuAssignment_2"
-    // InternalRoom.g:25585:1: rule__SubSystemClass__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:25632: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:25636:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:25637:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:25590:1: ( ruleDocumentation )
-            // InternalRoom.g:25591:1: ruleDocumentation
+            // InternalRoom.g:25637:1: ( ruleDocumentation )
+            // InternalRoom.g:25638:1: ruleDocumentation
             {
              before(grammarAccess.getSubSystemClassAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69223,17 +69379,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubSystemClass__AnnotationsAssignment_4"
-    // InternalRoom.g:25600:1: rule__SubSystemClass__AnnotationsAssignment_4 : ( ruleAnnotation ) ;
+    // InternalRoom.g:25647: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:25651:1: ( ( ruleAnnotation ) )
+            // InternalRoom.g:25652:1: ( ruleAnnotation )
             {
-            // InternalRoom.g:25605:1: ( ruleAnnotation )
-            // InternalRoom.g:25606:1: ruleAnnotation
+            // InternalRoom.g:25652:1: ( ruleAnnotation )
+            // InternalRoom.g:25653:1: ruleAnnotation
             {
              before(grammarAccess.getSubSystemClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69264,17 +69420,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:25662: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:25666:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25667:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25620:1: ( ruleDetailCode )
-            // InternalRoom.g:25621:1: ruleDetailCode
+            // InternalRoom.g:25667:1: ( ruleDetailCode )
+            // InternalRoom.g:25668:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode1DetailCodeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69305,17 +69461,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:25677: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:25681:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25682:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25635:1: ( ruleDetailCode )
-            // InternalRoom.g:25636:1: ruleDetailCode
+            // InternalRoom.g:25682:1: ( ruleDetailCode )
+            // InternalRoom.g:25683:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode2DetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69346,17 +69502,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:25692: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:25696:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:25697:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:25650:1: ( ruleDetailCode )
-            // InternalRoom.g:25651:1: ruleDetailCode
+            // InternalRoom.g:25697:1: ( ruleDetailCode )
+            // InternalRoom.g:25698:1: ruleDetailCode
             {
              before(grammarAccess.getSubSystemClassAccess().getUserCode3DetailCodeParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69387,17 +69543,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:25707: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:25711:1: ( ( ruleActorInstanceMapping ) )
+            // InternalRoom.g:25712:1: ( ruleActorInstanceMapping )
             {
-            // InternalRoom.g:25665:1: ( ruleActorInstanceMapping )
-            // InternalRoom.g:25666:1: ruleActorInstanceMapping
+            // InternalRoom.g:25712:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:25713:1: ruleActorInstanceMapping
             {
              before(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_8_0_0()); 
             pushFollow(FOLLOW_2);
@@ -69428,17 +69584,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:25722: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:25726:1: ( ( ruleLogicalThread ) )
+            // InternalRoom.g:25727:1: ( ruleLogicalThread )
             {
-            // InternalRoom.g:25680:1: ( ruleLogicalThread )
-            // InternalRoom.g:25681:1: ruleLogicalThread
+            // InternalRoom.g:25727:1: ( ruleLogicalThread )
+            // InternalRoom.g:25728:1: ruleLogicalThread
             {
              before(grammarAccess.getSubSystemClassAccess().getThreadsLogicalThreadParserRuleCall_8_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69469,17 +69625,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:25737: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:25741:1: ( ( ruleLayerConnection ) )
+            // InternalRoom.g:25742:1: ( ruleLayerConnection )
             {
-            // InternalRoom.g:25695:1: ( ruleLayerConnection )
-            // InternalRoom.g:25696:1: ruleLayerConnection
+            // InternalRoom.g:25742:1: ( ruleLayerConnection )
+            // InternalRoom.g:25743:1: ruleLayerConnection
             {
              before(grammarAccess.getSubSystemClassAccess().getConnectionsLayerConnectionParserRuleCall_8_2_0()); 
             pushFollow(FOLLOW_2);
@@ -69510,17 +69666,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:25752: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:25756:1: ( ( ruleBinding ) )
+            // InternalRoom.g:25757:1: ( ruleBinding )
             {
-            // InternalRoom.g:25710:1: ( ruleBinding )
-            // InternalRoom.g:25711:1: ruleBinding
+            // InternalRoom.g:25757:1: ( ruleBinding )
+            // InternalRoom.g:25758:1: ruleBinding
             {
              before(grammarAccess.getSubSystemClassAccess().getBindingsBindingParserRuleCall_8_3_0()); 
             pushFollow(FOLLOW_2);
@@ -69551,17 +69707,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:25767: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:25771:1: ( ( ruleActorRef ) )
+            // InternalRoom.g:25772:1: ( ruleActorRef )
             {
-            // InternalRoom.g:25725:1: ( ruleActorRef )
-            // InternalRoom.g:25726:1: ruleActorRef
+            // InternalRoom.g:25772:1: ( ruleActorRef )
+            // InternalRoom.g:25773:1: ruleActorRef
             {
              before(grammarAccess.getSubSystemClassAccess().getActorRefsActorRefParserRuleCall_8_4_0()); 
             pushFollow(FOLLOW_2);
@@ -69592,17 +69748,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:25782: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:25786:1: ( ( ruleSPP ) )
+            // InternalRoom.g:25787:1: ( ruleSPP )
             {
-            // InternalRoom.g:25740:1: ( ruleSPP )
-            // InternalRoom.g:25741:1: ruleSPP
+            // InternalRoom.g:25787:1: ( ruleSPP )
+            // InternalRoom.g:25788:1: ruleSPP
             {
              before(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsSPPParserRuleCall_8_5_0()); 
             pushFollow(FOLLOW_2);
@@ -69633,17 +69789,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:25797: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:25801:1: ( ( rulePort ) )
+            // InternalRoom.g:25802:1: ( rulePort )
             {
-            // InternalRoom.g:25755:1: ( rulePort )
-            // InternalRoom.g:25756:1: rulePort
+            // InternalRoom.g:25802:1: ( rulePort )
+            // InternalRoom.g:25803:1: rulePort
             {
              before(grammarAccess.getSubSystemClassAccess().getRelayPortsPortParserRuleCall_8_6_0()); 
             pushFollow(FOLLOW_2);
@@ -69674,17 +69830,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LogicalThread__NameAssignment_1"
-    // InternalRoom.g:25765:1: rule__LogicalThread__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:25812: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:25816:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25817:1: ( RULE_ID )
             {
-            // InternalRoom.g:25770:1: ( RULE_ID )
-            // InternalRoom.g:25771:1: RULE_ID
+            // InternalRoom.g:25817:1: ( RULE_ID )
+            // InternalRoom.g:25818:1: RULE_ID
             {
              before(grammarAccess.getLogicalThreadAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69711,17 +69867,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__PathAssignment_1"
-    // InternalRoom.g:25780:1: rule__ActorInstanceMapping__PathAssignment_1 : ( ruleRefPath ) ;
+    // InternalRoom.g:25827: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:25831:1: ( ( ruleRefPath ) )
+            // InternalRoom.g:25832:1: ( ruleRefPath )
             {
-            // InternalRoom.g:25785:1: ( ruleRefPath )
-            // InternalRoom.g:25786:1: ruleRefPath
+            // InternalRoom.g:25832:1: ( ruleRefPath )
+            // InternalRoom.g:25833:1: ruleRefPath
             {
              before(grammarAccess.getActorInstanceMappingAccess().getPathRefPathParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69752,21 +69908,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorInstanceMapping__ThreadAssignment_3"
-    // InternalRoom.g:25795:1: rule__ActorInstanceMapping__ThreadAssignment_3 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25842: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:25846:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25847:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25800:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25801:1: ( RULE_ID )
+            // InternalRoom.g:25847:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25848:1: ( RULE_ID )
             {
              before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadCrossReference_3_0()); 
-            // InternalRoom.g:25802:1: ( RULE_ID )
-            // InternalRoom.g:25803:1: RULE_ID
+            // InternalRoom.g:25849:1: ( RULE_ID )
+            // InternalRoom.g:25850:1: RULE_ID
             {
              before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadIDTerminalRuleCall_3_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69797,17 +69953,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:25861: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:25865:1: ( ( ruleActorInstanceMapping ) )
+            // InternalRoom.g:25866:1: ( ruleActorInstanceMapping )
             {
-            // InternalRoom.g:25819:1: ( ruleActorInstanceMapping )
-            // InternalRoom.g:25820:1: ruleActorInstanceMapping
+            // InternalRoom.g:25866:1: ( ruleActorInstanceMapping )
+            // InternalRoom.g:25867:1: ruleActorInstanceMapping
             {
              before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69838,17 +69994,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefPath__RefsAssignment_0"
-    // InternalRoom.g:25829:1: rule__RefPath__RefsAssignment_0 : ( ruleRefSegment ) ;
+    // InternalRoom.g:25876: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:25880:1: ( ( ruleRefSegment ) )
+            // InternalRoom.g:25881:1: ( ruleRefSegment )
             {
-            // InternalRoom.g:25834:1: ( ruleRefSegment )
-            // InternalRoom.g:25835:1: ruleRefSegment
+            // InternalRoom.g:25881:1: ( ruleRefSegment )
+            // InternalRoom.g:25882:1: ruleRefSegment
             {
              before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -69879,17 +70035,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:25891: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:25895:1: ( ( ruleRefSegment ) )
+            // InternalRoom.g:25896:1: ( ruleRefSegment )
             {
-            // InternalRoom.g:25849:1: ( ruleRefSegment )
-            // InternalRoom.g:25850:1: ruleRefSegment
+            // InternalRoom.g:25896:1: ( ruleRefSegment )
+            // InternalRoom.g:25897:1: ruleRefSegment
             {
              before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -69920,17 +70076,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSegment__RefAssignment_0"
-    // InternalRoom.g:25859:1: rule__RefSegment__RefAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:25906: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:25910:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25911:1: ( RULE_ID )
             {
-            // InternalRoom.g:25864:1: ( RULE_ID )
-            // InternalRoom.g:25865:1: RULE_ID
+            // InternalRoom.g:25911:1: ( RULE_ID )
+            // InternalRoom.g:25912:1: RULE_ID
             {
              before(grammarAccess.getRefSegmentAccess().getRefIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -69957,17 +70113,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:25921: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:25925:1: ( ( RULE_INT ) )
+            // InternalRoom.g:25926:1: ( RULE_INT )
             {
-            // InternalRoom.g:25879:1: ( RULE_INT )
-            // InternalRoom.g:25880:1: RULE_INT
+            // InternalRoom.g:25926:1: ( RULE_INT )
+            // InternalRoom.g:25927:1: RULE_INT
             {
              before(grammarAccess.getRefSegmentAccess().getIdxINTTerminalRuleCall_1_1_0()); 
             match(input,RULE_INT,FOLLOW_2); 
@@ -69994,17 +70150,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Endpoint1Assignment_1"
-    // InternalRoom.g:25889:1: rule__Binding__Endpoint1Assignment_1 : ( ruleBindingEndPoint ) ;
+    // InternalRoom.g:25936: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:25940:1: ( ( ruleBindingEndPoint ) )
+            // InternalRoom.g:25941:1: ( ruleBindingEndPoint )
             {
-            // InternalRoom.g:25894:1: ( ruleBindingEndPoint )
-            // InternalRoom.g:25895:1: ruleBindingEndPoint
+            // InternalRoom.g:25941:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:25942:1: ruleBindingEndPoint
             {
              before(grammarAccess.getBindingAccess().getEndpoint1BindingEndPointParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70035,17 +70191,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Binding__Endpoint2Assignment_3"
-    // InternalRoom.g:25904:1: rule__Binding__Endpoint2Assignment_3 : ( ruleBindingEndPoint ) ;
+    // InternalRoom.g:25951: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:25955:1: ( ( ruleBindingEndPoint ) )
+            // InternalRoom.g:25956:1: ( ruleBindingEndPoint )
             {
-            // InternalRoom.g:25909:1: ( ruleBindingEndPoint )
-            // InternalRoom.g:25910:1: ruleBindingEndPoint
+            // InternalRoom.g:25956:1: ( ruleBindingEndPoint )
+            // InternalRoom.g:25957:1: ruleBindingEndPoint
             {
              before(grammarAccess.getBindingAccess().getEndpoint2BindingEndPointParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70076,21 +70232,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:25966: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:25970:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25971:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25924:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25925:1: ( RULE_ID )
+            // InternalRoom.g:25971:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25972:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefCrossReference_0_0_0()); 
-            // InternalRoom.g:25926:1: ( RULE_ID )
-            // InternalRoom.g:25927:1: RULE_ID
+            // InternalRoom.g:25973:1: ( RULE_ID )
+            // InternalRoom.g:25974:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70121,21 +70277,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__BindingEndPoint__PortAssignment_1"
-    // InternalRoom.g:25938:1: rule__BindingEndPoint__PortAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:25985: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:25989:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:25990:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25943:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25944:1: ( RULE_ID )
+            // InternalRoom.g:25990:1: ( ( RULE_ID ) )
+            // InternalRoom.g:25991:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getPortPortCrossReference_1_0()); 
-            // InternalRoom.g:25945:1: ( RULE_ID )
-            // InternalRoom.g:25946:1: RULE_ID
+            // InternalRoom.g:25992:1: ( RULE_ID )
+            // InternalRoom.g:25993:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getPortPortIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70166,21 +70322,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:26004: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:26008:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26009:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:25962:1: ( ( RULE_ID ) )
-            // InternalRoom.g:25963:1: ( RULE_ID )
+            // InternalRoom.g:26009:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26010:1: ( RULE_ID )
             {
              before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolCrossReference_2_1_0()); 
-            // InternalRoom.g:25964:1: ( RULE_ID )
-            // InternalRoom.g:25965:1: RULE_ID
+            // InternalRoom.g:26011:1: ( RULE_ID )
+            // InternalRoom.g:26012:1: RULE_ID
             {
              before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolIDTerminalRuleCall_2_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70211,17 +70367,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__FromAssignment_1"
-    // InternalRoom.g:25976:1: rule__LayerConnection__FromAssignment_1 : ( ruleSAPoint ) ;
+    // InternalRoom.g:26023: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:26027:1: ( ( ruleSAPoint ) )
+            // InternalRoom.g:26028:1: ( ruleSAPoint )
             {
-            // InternalRoom.g:25981:1: ( ruleSAPoint )
-            // InternalRoom.g:25982:1: ruleSAPoint
+            // InternalRoom.g:26028:1: ( ruleSAPoint )
+            // InternalRoom.g:26029:1: ruleSAPoint
             {
              before(grammarAccess.getLayerConnectionAccess().getFromSAPointParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70252,17 +70408,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__LayerConnection__ToAssignment_3"
-    // InternalRoom.g:25991:1: rule__LayerConnection__ToAssignment_3 : ( ruleSPPoint ) ;
+    // InternalRoom.g:26038: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:26042:1: ( ( ruleSPPoint ) )
+            // InternalRoom.g:26043:1: ( ruleSPPoint )
             {
-            // InternalRoom.g:25996:1: ( ruleSPPoint )
-            // InternalRoom.g:25997:1: ruleSPPoint
+            // InternalRoom.g:26043:1: ( ruleSPPoint )
+            // InternalRoom.g:26044:1: ruleSPPoint
             {
              before(grammarAccess.getLayerConnectionAccess().getToSPPointParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70293,21 +70449,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefSAPoint__RefAssignment_1"
-    // InternalRoom.g:26006:1: rule__RefSAPoint__RefAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26053: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:26057:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26058:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26011:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26012:1: ( RULE_ID )
+            // InternalRoom.g:26058:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26059:1: ( RULE_ID )
             {
              before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefCrossReference_1_0()); 
-            // InternalRoom.g:26013:1: ( RULE_ID )
-            // InternalRoom.g:26014:1: RULE_ID
+            // InternalRoom.g:26060:1: ( RULE_ID )
+            // InternalRoom.g:26061:1: RULE_ID
             {
              before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70338,21 +70494,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RelaySAPoint__RelayAssignment_1"
-    // InternalRoom.g:26025:1: rule__RelaySAPoint__RelayAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26072: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:26076:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26077:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26030:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26031:1: ( RULE_ID )
+            // InternalRoom.g:26077:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26078:1: ( RULE_ID )
             {
              before(grammarAccess.getRelaySAPointAccess().getRelaySPPCrossReference_1_0()); 
-            // InternalRoom.g:26032:1: ( RULE_ID )
-            // InternalRoom.g:26033:1: RULE_ID
+            // InternalRoom.g:26079:1: ( RULE_ID )
+            // InternalRoom.g:26080:1: RULE_ID
             {
              before(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70383,21 +70539,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__RefAssignment_0"
-    // InternalRoom.g:26044:1: rule__SPPoint__RefAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26091: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:26095:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26096:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26049:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26050:1: ( RULE_ID )
+            // InternalRoom.g:26096:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26097:1: ( RULE_ID )
             {
              before(grammarAccess.getSPPointAccess().getRefActorContainerRefCrossReference_0_0()); 
-            // InternalRoom.g:26051:1: ( RULE_ID )
-            // InternalRoom.g:26052:1: RULE_ID
+            // InternalRoom.g:26098:1: ( RULE_ID )
+            // InternalRoom.g:26099:1: RULE_ID
             {
              before(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70428,21 +70584,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SPPoint__ServiceAssignment_2"
-    // InternalRoom.g:26063:1: rule__SPPoint__ServiceAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:26110: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:26114:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:26115:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:26068:1: ( ( RULE_ID ) )
-            // InternalRoom.g:26069:1: ( RULE_ID )
+            // InternalRoom.g:26115:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26116:1: ( RULE_ID )
             {
              before(grammarAccess.getSPPointAccess().getServiceSPPCrossReference_2_0()); 
-            // InternalRoom.g:26070:1: ( RULE_ID )
-            // InternalRoom.g:26071:1: RULE_ID
+            // InternalRoom.g:26117:1: ( RULE_ID )
+            // InternalRoom.g:26118:1: RULE_ID
             {
              before(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70473,17 +70629,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__RefTypeAssignment_0"
-    // InternalRoom.g:26082:1: rule__ActorRef__RefTypeAssignment_0 : ( ruleReferenceType ) ;
+    // InternalRoom.g:26129: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:26133:1: ( ( ruleReferenceType ) )
+            // InternalRoom.g:26134:1: ( ruleReferenceType )
             {
-            // InternalRoom.g:26087:1: ( ruleReferenceType )
-            // InternalRoom.g:26088:1: ruleReferenceType
+            // InternalRoom.g:26134:1: ( ruleReferenceType )
+            // InternalRoom.g:26135:1: ruleReferenceType
             {
              before(grammarAccess.getActorRefAccess().getRefTypeReferenceTypeEnumRuleCall_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70514,17 +70670,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__NameAssignment_2"
-    // InternalRoom.g:26097:1: rule__ActorRef__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:26144: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:26148:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26149:1: ( RULE_ID )
             {
-            // InternalRoom.g:26102:1: ( RULE_ID )
-            // InternalRoom.g:26103:1: RULE_ID
+            // InternalRoom.g:26149:1: ( RULE_ID )
+            // InternalRoom.g:26150:1: RULE_ID
             {
              before(grammarAccess.getActorRefAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -70551,17 +70707,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__MultiplicityAssignment_3"
-    // InternalRoom.g:26112:1: rule__ActorRef__MultiplicityAssignment_3 : ( ruleMULTIPLICITY ) ;
+    // InternalRoom.g:26159: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:26163:1: ( ( ruleMULTIPLICITY ) )
+            // InternalRoom.g:26164:1: ( ruleMULTIPLICITY )
             {
-            // InternalRoom.g:26117:1: ( ruleMULTIPLICITY )
-            // InternalRoom.g:26118:1: ruleMULTIPLICITY
+            // InternalRoom.g:26164:1: ( ruleMULTIPLICITY )
+            // InternalRoom.g:26165:1: ruleMULTIPLICITY
             {
              before(grammarAccess.getActorRefAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70592,21 +70748,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__TypeAssignment_5"
-    // InternalRoom.g:26127:1: rule__ActorRef__TypeAssignment_5 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:26174: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:26178:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:26179:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:26132:1: ( ( ruleFQN ) )
-            // InternalRoom.g:26133:1: ( ruleFQN )
+            // InternalRoom.g:26179:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26180:1: ( ruleFQN )
             {
              before(grammarAccess.getActorRefAccess().getTypeActorClassCrossReference_5_0()); 
-            // InternalRoom.g:26134:1: ( ruleFQN )
-            // InternalRoom.g:26135:1: ruleFQN
+            // InternalRoom.g:26181:1: ( ruleFQN )
+            // InternalRoom.g:26182:1: ruleFQN
             {
              before(grammarAccess.getActorRefAccess().getTypeActorClassFQNParserRuleCall_5_0_1()); 
             pushFollow(FOLLOW_2);
@@ -70641,17 +70797,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ActorRef__DocuAssignment_6"
-    // InternalRoom.g:26146:1: rule__ActorRef__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26193: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:26197:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26198:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26151:1: ( ruleDocumentation )
-            // InternalRoom.g:26152:1: ruleDocumentation
+            // InternalRoom.g:26198:1: ( ruleDocumentation )
+            // InternalRoom.g:26199:1: ruleDocumentation
             {
              before(grammarAccess.getActorRefAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -70682,17 +70838,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:26209: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:26213:1: ( ( ruleState ) )
+            // InternalRoom.g:26214:1: ( ruleState )
             {
-            // InternalRoom.g:26167:1: ( ruleState )
-            // InternalRoom.g:26168:1: ruleState
+            // InternalRoom.g:26214:1: ( ruleState )
+            // InternalRoom.g:26215:1: ruleState
             {
              before(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70723,17 +70879,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:26224: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:26228:1: ( ( ruleTrPoint ) )
+            // InternalRoom.g:26229:1: ( ruleTrPoint )
             {
-            // InternalRoom.g:26182:1: ( ruleTrPoint )
-            // InternalRoom.g:26183:1: ruleTrPoint
+            // InternalRoom.g:26229:1: ( ruleTrPoint )
+            // InternalRoom.g:26230:1: ruleTrPoint
             {
              before(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70764,17 +70920,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:26239: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:26243:1: ( ( ruleChoicePoint ) )
+            // InternalRoom.g:26244:1: ( ruleChoicePoint )
             {
-            // InternalRoom.g:26197:1: ( ruleChoicePoint )
-            // InternalRoom.g:26198:1: ruleChoicePoint
+            // InternalRoom.g:26244:1: ( ruleChoicePoint )
+            // InternalRoom.g:26245:1: ruleChoicePoint
             {
              before(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); 
             pushFollow(FOLLOW_2);
@@ -70805,17 +70961,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:26254: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:26258:1: ( ( ruleTransition ) )
+            // InternalRoom.g:26259:1: ( ruleTransition )
             {
-            // InternalRoom.g:26212:1: ( ruleTransition )
-            // InternalRoom.g:26213:1: ruleTransition
+            // InternalRoom.g:26259:1: ( ruleTransition )
+            // InternalRoom.g:26260:1: ruleTransition
             {
              before(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); 
             pushFollow(FOLLOW_2);
@@ -70846,17 +71002,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:26269: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:26273:1: ( ( ruleRefinedTransition ) )
+            // InternalRoom.g:26274:1: ( ruleRefinedTransition )
             {
-            // InternalRoom.g:26227:1: ( ruleRefinedTransition )
-            // InternalRoom.g:26228:1: ruleRefinedTransition
+            // InternalRoom.g:26274:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26275:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); 
             pushFollow(FOLLOW_2);
@@ -70887,17 +71043,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:26284: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:26288:1: ( ( ruleState ) )
+            // InternalRoom.g:26289:1: ( ruleState )
             {
-            // InternalRoom.g:26242:1: ( ruleState )
-            // InternalRoom.g:26243:1: ruleState
+            // InternalRoom.g:26289:1: ( ruleState )
+            // InternalRoom.g:26290:1: ruleState
             {
              before(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); 
             pushFollow(FOLLOW_2);
@@ -70928,17 +71084,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:26299: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:26303:1: ( ( ruleTrPoint ) )
+            // InternalRoom.g:26304:1: ( ruleTrPoint )
             {
-            // InternalRoom.g:26257:1: ( ruleTrPoint )
-            // InternalRoom.g:26258:1: ruleTrPoint
+            // InternalRoom.g:26304:1: ( ruleTrPoint )
+            // InternalRoom.g:26305:1: ruleTrPoint
             {
              before(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -70969,17 +71125,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:26314: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:26318:1: ( ( ruleChoicePoint ) )
+            // InternalRoom.g:26319:1: ( ruleChoicePoint )
             {
-            // InternalRoom.g:26272:1: ( ruleChoicePoint )
-            // InternalRoom.g:26273:1: ruleChoicePoint
+            // InternalRoom.g:26319:1: ( ruleChoicePoint )
+            // InternalRoom.g:26320:1: ruleChoicePoint
             {
              before(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71010,17 +71166,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:26329: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:26333:1: ( ( ruleTransition ) )
+            // InternalRoom.g:26334:1: ( ruleTransition )
             {
-            // InternalRoom.g:26287:1: ( ruleTransition )
-            // InternalRoom.g:26288:1: ruleTransition
+            // InternalRoom.g:26334:1: ( ruleTransition )
+            // InternalRoom.g:26335:1: ruleTransition
             {
              before(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); 
             pushFollow(FOLLOW_2);
@@ -71051,17 +71207,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:26344: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:26348:1: ( ( ruleRefinedTransition ) )
+            // InternalRoom.g:26349:1: ( ruleRefinedTransition )
             {
-            // InternalRoom.g:26302:1: ( ruleRefinedTransition )
-            // InternalRoom.g:26303:1: ruleRefinedTransition
+            // InternalRoom.g:26349:1: ( ruleRefinedTransition )
+            // InternalRoom.g:26350:1: ruleRefinedTransition
             {
              before(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); 
             pushFollow(FOLLOW_2);
@@ -71092,17 +71248,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__NameAssignment_1"
-    // InternalRoom.g:26312:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26359: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:26363:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26364:1: ( RULE_ID )
             {
-            // InternalRoom.g:26317:1: ( RULE_ID )
-            // InternalRoom.g:26318:1: RULE_ID
+            // InternalRoom.g:26364:1: ( RULE_ID )
+            // InternalRoom.g:26365:1: RULE_ID
             {
              before(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71129,17 +71285,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleState__DocuAssignment_2"
-    // InternalRoom.g:26327:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26374: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:26378:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26379:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26332:1: ( ruleDocumentation )
-            // InternalRoom.g:26333:1: ruleDocumentation
+            // InternalRoom.g:26379:1: ( ruleDocumentation )
+            // InternalRoom.g:26380:1: ruleDocumentation
             {
              before(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71170,17 +71326,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:26389: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:26393:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26394:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26347:1: ( ruleDetailCode )
-            // InternalRoom.g:26348:1: ruleDetailCode
+            // InternalRoom.g:26394:1: ( ruleDetailCode )
+            // InternalRoom.g:26395:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71211,17 +71367,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:26404: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:26408:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26409:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26362:1: ( ruleDetailCode )
-            // InternalRoom.g:26363:1: ruleDetailCode
+            // InternalRoom.g:26409:1: ( ruleDetailCode )
+            // InternalRoom.g:26410:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71252,17 +71408,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:26419: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:26423:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26424:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26377:1: ( ruleDetailCode )
-            // InternalRoom.g:26378:1: ruleDetailCode
+            // InternalRoom.g:26424:1: ( ruleDetailCode )
+            // InternalRoom.g:26425:1: ruleDetailCode
             {
              before(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71293,17 +71449,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:26434: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:26438:1: ( ( ruleStateGraph ) )
+            // InternalRoom.g:26439:1: ( ruleStateGraph )
             {
-            // InternalRoom.g:26392:1: ( ruleStateGraph )
-            // InternalRoom.g:26393:1: ruleStateGraph
+            // InternalRoom.g:26439:1: ( ruleStateGraph )
+            // InternalRoom.g:26440:1: ruleStateGraph
             {
              before(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71334,21 +71490,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__TargetAssignment_1"
-    // InternalRoom.g:26402:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:26449: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:26453:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:26454:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:26407:1: ( ( ruleFQN ) )
-            // InternalRoom.g:26408:1: ( ruleFQN )
+            // InternalRoom.g:26454:1: ( ( ruleFQN ) )
+            // InternalRoom.g:26455:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); 
-            // InternalRoom.g:26409:1: ( ruleFQN )
-            // InternalRoom.g:26410:1: ruleFQN
+            // InternalRoom.g:26456:1: ( ruleFQN )
+            // InternalRoom.g:26457:1: ruleFQN
             {
              before(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -71383,17 +71539,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedState__DocuAssignment_2"
-    // InternalRoom.g:26421:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26468: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:26472:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26473:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26426:1: ( ruleDocumentation )
-            // InternalRoom.g:26427:1: ruleDocumentation
+            // InternalRoom.g:26473:1: ( ruleDocumentation )
+            // InternalRoom.g:26474:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71424,17 +71580,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:26483: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:26487:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26488:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26441:1: ( ruleDetailCode )
-            // InternalRoom.g:26442:1: ruleDetailCode
+            // InternalRoom.g:26488:1: ( ruleDetailCode )
+            // InternalRoom.g:26489:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71465,17 +71621,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:26498: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:26502:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26503:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26456:1: ( ruleDetailCode )
-            // InternalRoom.g:26457:1: ruleDetailCode
+            // InternalRoom.g:26503:1: ( ruleDetailCode )
+            // InternalRoom.g:26504:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71506,17 +71662,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:26513: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:26517:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26518:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26471:1: ( ruleDetailCode )
-            // InternalRoom.g:26472:1: ruleDetailCode
+            // InternalRoom.g:26518:1: ( ruleDetailCode )
+            // InternalRoom.g:26519:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71547,17 +71703,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:26528: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:26532:1: ( ( ruleStateGraph ) )
+            // InternalRoom.g:26533:1: ( ruleStateGraph )
             {
-            // InternalRoom.g:26486:1: ( ruleStateGraph )
-            // InternalRoom.g:26487:1: ruleStateGraph
+            // InternalRoom.g:26533:1: ( ruleStateGraph )
+            // InternalRoom.g:26534:1: ruleStateGraph
             {
              before(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); 
             pushFollow(FOLLOW_2);
@@ -71588,17 +71744,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:26543: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:26547:1: ( ( RULE_CC_STRING ) )
+            // InternalRoom.g:26548:1: ( RULE_CC_STRING )
             {
-            // InternalRoom.g:26501:1: ( RULE_CC_STRING )
-            // InternalRoom.g:26502:1: RULE_CC_STRING
+            // InternalRoom.g:26548:1: ( RULE_CC_STRING )
+            // InternalRoom.g:26549:1: RULE_CC_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesCC_STRINGTerminalRuleCall_0_1_0()); 
             match(input,RULE_CC_STRING,FOLLOW_2); 
@@ -71625,21 +71781,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__DetailCode__UsedAssignment_1_0"
-    // InternalRoom.g:26511:1: rule__DetailCode__UsedAssignment_1_0 : ( ( '{' ) ) ;
+    // InternalRoom.g:26558: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:26562:1: ( ( ( '{' ) ) )
+            // InternalRoom.g:26563:1: ( ( '{' ) )
             {
-            // InternalRoom.g:26516:1: ( ( '{' ) )
-            // InternalRoom.g:26517:1: ( '{' )
+            // InternalRoom.g:26563:1: ( ( '{' ) )
+            // InternalRoom.g:26564:1: ( '{' )
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
-            // InternalRoom.g:26518:1: ( '{' )
-            // InternalRoom.g:26519:1: '{'
+            // InternalRoom.g:26565:1: ( '{' )
+            // InternalRoom.g:26566:1: '{'
             {
              before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0_0()); 
             match(input,44,FOLLOW_2); 
@@ -71670,17 +71826,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:26581: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:26585:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:26586:1: ( RULE_STRING )
             {
-            // InternalRoom.g:26539:1: ( RULE_STRING )
-            // InternalRoom.g:26540:1: RULE_STRING
+            // InternalRoom.g:26586:1: ( RULE_STRING )
+            // InternalRoom.g:26587:1: RULE_STRING
             {
              before(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_1_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -71707,21 +71863,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__HandlerAssignment_0"
-    // InternalRoom.g:26549:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ;
+    // InternalRoom.g:26596: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:26600:1: ( ( ( 'handler' ) ) )
+            // InternalRoom.g:26601:1: ( ( 'handler' ) )
             {
-            // InternalRoom.g:26554:1: ( ( 'handler' ) )
-            // InternalRoom.g:26555:1: ( 'handler' )
+            // InternalRoom.g:26601:1: ( ( 'handler' ) )
+            // InternalRoom.g:26602:1: ( 'handler' )
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
-            // InternalRoom.g:26556:1: ( 'handler' )
-            // InternalRoom.g:26557:1: 'handler'
+            // InternalRoom.g:26603:1: ( 'handler' )
+            // InternalRoom.g:26604:1: 'handler'
             {
              before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); 
             match(input,131,FOLLOW_2); 
@@ -71752,17 +71908,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TransitionPoint__NameAssignment_2"
-    // InternalRoom.g:26572:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:26619: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:26623:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26624:1: ( RULE_ID )
             {
-            // InternalRoom.g:26577:1: ( RULE_ID )
-            // InternalRoom.g:26578:1: RULE_ID
+            // InternalRoom.g:26624:1: ( RULE_ID )
+            // InternalRoom.g:26625:1: RULE_ID
             {
              before(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71789,17 +71945,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EntryPoint__NameAssignment_1"
-    // InternalRoom.g:26587:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26634: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:26638:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26639:1: ( RULE_ID )
             {
-            // InternalRoom.g:26592:1: ( RULE_ID )
-            // InternalRoom.g:26593:1: RULE_ID
+            // InternalRoom.g:26639:1: ( RULE_ID )
+            // InternalRoom.g:26640:1: RULE_ID
             {
              before(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71826,17 +71982,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ExitPoint__NameAssignment_1"
-    // InternalRoom.g:26602:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26649: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:26653:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26654:1: ( RULE_ID )
             {
-            // InternalRoom.g:26607:1: ( RULE_ID )
-            // InternalRoom.g:26608:1: RULE_ID
+            // InternalRoom.g:26654:1: ( RULE_ID )
+            // InternalRoom.g:26655:1: RULE_ID
             {
              before(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71863,17 +72019,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__NameAssignment_1"
-    // InternalRoom.g:26617:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26664: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:26668:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26669:1: ( RULE_ID )
             {
-            // InternalRoom.g:26622:1: ( RULE_ID )
-            // InternalRoom.g:26623:1: RULE_ID
+            // InternalRoom.g:26669:1: ( RULE_ID )
+            // InternalRoom.g:26670:1: RULE_ID
             {
              before(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71900,17 +72056,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicePoint__DocuAssignment_2"
-    // InternalRoom.g:26632:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26679: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:26683:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26684:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26637:1: ( ruleDocumentation )
-            // InternalRoom.g:26638:1: ruleDocumentation
+            // InternalRoom.g:26684:1: ( ruleDocumentation )
+            // InternalRoom.g:26685:1: ruleDocumentation
             {
              before(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -71941,17 +72097,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__NameAssignment_1"
-    // InternalRoom.g:26647:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26694: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:26698:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26699:1: ( RULE_ID )
             {
-            // InternalRoom.g:26652:1: ( RULE_ID )
-            // InternalRoom.g:26653:1: RULE_ID
+            // InternalRoom.g:26699:1: ( RULE_ID )
+            // InternalRoom.g:26700:1: RULE_ID
             {
              before(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -71978,17 +72134,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__ToAssignment_5"
-    // InternalRoom.g:26662:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26709: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:26713:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26714:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26667:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26668:1: ruleTransitionTerminal
+            // InternalRoom.g:26714:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26715:1: ruleTransitionTerminal
             {
              before(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72019,17 +72175,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InitialTransition__DocuAssignment_6"
-    // InternalRoom.g:26677:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26724: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:26728:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26729:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26682:1: ( ruleDocumentation )
-            // InternalRoom.g:26683:1: ruleDocumentation
+            // InternalRoom.g:26729:1: ( ruleDocumentation )
+            // InternalRoom.g:26730:1: ruleDocumentation
             {
              before(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72060,17 +72216,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:26739: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:26743:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26744:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26697:1: ( ruleDetailCode )
-            // InternalRoom.g:26698:1: ruleDetailCode
+            // InternalRoom.g:26744:1: ( ruleDetailCode )
+            // InternalRoom.g:26745:1: ruleDetailCode
             {
              before(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72101,17 +72257,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__NameAssignment_1"
-    // InternalRoom.g:26707:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26754: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:26758:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26759:1: ( RULE_ID )
             {
-            // InternalRoom.g:26712:1: ( RULE_ID )
-            // InternalRoom.g:26713:1: RULE_ID
+            // InternalRoom.g:26759:1: ( RULE_ID )
+            // InternalRoom.g:26760:1: RULE_ID
             {
              before(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72138,17 +72294,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__FromAssignment_3"
-    // InternalRoom.g:26722:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26769: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:26773:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26774:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26727:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26728:1: ruleTransitionTerminal
+            // InternalRoom.g:26774:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26775:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72179,17 +72335,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__ToAssignment_5"
-    // InternalRoom.g:26737:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26784: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:26788:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26789:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26742:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26743:1: ruleTransitionTerminal
+            // InternalRoom.g:26789:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26790:1: ruleTransitionTerminal
             {
              before(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72220,17 +72376,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ContinuationTransition__DocuAssignment_6"
-    // InternalRoom.g:26752:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26799: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:26803:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26804:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26757:1: ( ruleDocumentation )
-            // InternalRoom.g:26758:1: ruleDocumentation
+            // InternalRoom.g:26804:1: ( ruleDocumentation )
+            // InternalRoom.g:26805:1: ruleDocumentation
             {
              before(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72261,17 +72417,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:26814: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:26818:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26819:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26772:1: ( ruleDetailCode )
-            // InternalRoom.g:26773:1: ruleDetailCode
+            // InternalRoom.g:26819:1: ( ruleDetailCode )
+            // InternalRoom.g:26820:1: ruleDetailCode
             {
              before(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72302,17 +72458,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__NameAssignment_1"
-    // InternalRoom.g:26782:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26829: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:26833:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26834:1: ( RULE_ID )
             {
-            // InternalRoom.g:26787:1: ( RULE_ID )
-            // InternalRoom.g:26788:1: RULE_ID
+            // InternalRoom.g:26834:1: ( RULE_ID )
+            // InternalRoom.g:26835:1: RULE_ID
             {
              before(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72339,17 +72495,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__FromAssignment_3"
-    // InternalRoom.g:26797:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26844: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:26848:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26849:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26802:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26803:1: ruleTransitionTerminal
+            // InternalRoom.g:26849:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26850:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72380,17 +72536,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__ToAssignment_5"
-    // InternalRoom.g:26812:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26859: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:26863:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26864:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26817:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26818:1: ruleTransitionTerminal
+            // InternalRoom.g:26864:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26865:1: ruleTransitionTerminal
             {
              before(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72421,17 +72577,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__DocuAssignment_6"
-    // InternalRoom.g:26827:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26874: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:26878:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26879:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26832:1: ( ruleDocumentation )
-            // InternalRoom.g:26833:1: ruleDocumentation
+            // InternalRoom.g:26879:1: ( ruleDocumentation )
+            // InternalRoom.g:26880:1: ruleDocumentation
             {
              before(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72462,17 +72618,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_10"
-    // InternalRoom.g:26842:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ;
+    // InternalRoom.g:26889: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:26893:1: ( ( ruleTrigger ) )
+            // InternalRoom.g:26894:1: ( ruleTrigger )
             {
-            // InternalRoom.g:26847:1: ( ruleTrigger )
-            // InternalRoom.g:26848:1: ruleTrigger
+            // InternalRoom.g:26894:1: ( ruleTrigger )
+            // InternalRoom.g:26895:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
             pushFollow(FOLLOW_2);
@@ -72503,17 +72659,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:26904: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:26908:1: ( ( ruleTrigger ) )
+            // InternalRoom.g:26909:1: ( ruleTrigger )
             {
-            // InternalRoom.g:26862:1: ( ruleTrigger )
-            // InternalRoom.g:26863:1: ruleTrigger
+            // InternalRoom.g:26909:1: ( ruleTrigger )
+            // InternalRoom.g:26910:1: ruleTrigger
             {
              before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72544,17 +72700,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:26919: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:26923:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26924:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26877:1: ( ruleDetailCode )
-            // InternalRoom.g:26878:1: ruleDetailCode
+            // InternalRoom.g:26924:1: ( ruleDetailCode )
+            // InternalRoom.g:26925:1: ruleDetailCode
             {
              before(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72585,17 +72741,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__NameAssignment_1"
-    // InternalRoom.g:26887:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:26934: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:26938:1: ( ( RULE_ID ) )
+            // InternalRoom.g:26939:1: ( RULE_ID )
             {
-            // InternalRoom.g:26892:1: ( RULE_ID )
-            // InternalRoom.g:26893:1: RULE_ID
+            // InternalRoom.g:26939:1: ( RULE_ID )
+            // InternalRoom.g:26940:1: RULE_ID
             {
              before(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72622,17 +72778,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__FromAssignment_3"
-    // InternalRoom.g:26902:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26949: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:26953:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26954:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26907:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26908:1: ruleTransitionTerminal
+            // InternalRoom.g:26954:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26955:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72663,17 +72819,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__ToAssignment_5"
-    // InternalRoom.g:26917:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:26964: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:26968:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:26969:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26922:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26923:1: ruleTransitionTerminal
+            // InternalRoom.g:26969:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:26970:1: ruleTransitionTerminal
             {
              before(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72704,17 +72860,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__DocuAssignment_6"
-    // InternalRoom.g:26932:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:26979: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:26983:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:26984:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:26937:1: ( ruleDocumentation )
-            // InternalRoom.g:26938:1: ruleDocumentation
+            // InternalRoom.g:26984:1: ( ruleDocumentation )
+            // InternalRoom.g:26985:1: ruleDocumentation
             {
              before(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72745,17 +72901,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__GuardedTransition__GuardAssignment_9"
-    // InternalRoom.g:26947:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ;
+    // InternalRoom.g:26994: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:26998:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:26999:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26952:1: ( ruleDetailCode )
-            // InternalRoom.g:26953:1: ruleDetailCode
+            // InternalRoom.g:26999:1: ( ruleDetailCode )
+            // InternalRoom.g:27000:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -72786,17 +72942,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:27009: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:27013:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27014:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:26967:1: ( ruleDetailCode )
-            // InternalRoom.g:26968:1: ruleDetailCode
+            // InternalRoom.g:27014:1: ( ruleDetailCode )
+            // InternalRoom.g:27015:1: ruleDetailCode
             {
              before(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -72827,17 +72983,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__NameAssignment_1"
-    // InternalRoom.g:26977:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27024: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:27028:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27029:1: ( RULE_ID )
             {
-            // InternalRoom.g:26982:1: ( RULE_ID )
-            // InternalRoom.g:26983:1: RULE_ID
+            // InternalRoom.g:27029:1: ( RULE_ID )
+            // InternalRoom.g:27030:1: RULE_ID
             {
              before(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -72864,17 +73020,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__FromAssignment_3"
-    // InternalRoom.g:26992:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27039: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:27043:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27044:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:26997:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:26998:1: ruleTransitionTerminal
+            // InternalRoom.g:27044:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27045:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -72905,17 +73061,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ToAssignment_5"
-    // InternalRoom.g:27007:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ;
+    // InternalRoom.g:27054: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:27058:1: ( ( ruleTransitionTerminal ) )
+            // InternalRoom.g:27059:1: ( ruleTransitionTerminal )
             {
-            // InternalRoom.g:27012:1: ( ruleTransitionTerminal )
-            // InternalRoom.g:27013:1: ruleTransitionTerminal
+            // InternalRoom.g:27059:1: ( ruleTransitionTerminal )
+            // InternalRoom.g:27060:1: ruleTransitionTerminal
             {
              before(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -72946,17 +73102,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__DocuAssignment_6"
-    // InternalRoom.g:27022:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27069: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:27073:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27074:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27027:1: ( ruleDocumentation )
-            // InternalRoom.g:27028:1: ruleDocumentation
+            // InternalRoom.g:27074:1: ( ruleDocumentation )
+            // InternalRoom.g:27075:1: ruleDocumentation
             {
              before(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
             pushFollow(FOLLOW_2);
@@ -72987,17 +73143,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__CPBranchTransition__ConditionAssignment_9"
-    // InternalRoom.g:27037:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27084: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:27088:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27089:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27042:1: ( ruleDetailCode )
-            // InternalRoom.g:27043:1: ruleDetailCode
+            // InternalRoom.g:27089:1: ( ruleDetailCode )
+            // InternalRoom.g:27090:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
             pushFollow(FOLLOW_2);
@@ -73028,17 +73184,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:27099: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:27103:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27104:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27057:1: ( ruleDetailCode )
-            // InternalRoom.g:27058:1: ruleDetailCode
+            // InternalRoom.g:27104:1: ( ruleDetailCode )
+            // InternalRoom.g:27105:1: ruleDetailCode
             {
              before(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73069,21 +73225,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__TargetAssignment_1"
-    // InternalRoom.g:27067:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:27114: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:27118:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:27119:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:27072:1: ( ( ruleFQN ) )
-            // InternalRoom.g:27073:1: ( ruleFQN )
+            // InternalRoom.g:27119:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27120:1: ( ruleFQN )
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); 
-            // InternalRoom.g:27074:1: ( ruleFQN )
-            // InternalRoom.g:27075:1: ruleFQN
+            // InternalRoom.g:27121:1: ( ruleFQN )
+            // InternalRoom.g:27122:1: ruleFQN
             {
              before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -73118,17 +73274,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__DocuAssignment_2"
-    // InternalRoom.g:27086:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27133: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:27137:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27138:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27091:1: ( ruleDocumentation )
-            // InternalRoom.g:27092:1: ruleDocumentation
+            // InternalRoom.g:27138:1: ( ruleDocumentation )
+            // InternalRoom.g:27139:1: ruleDocumentation
             {
              before(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -73159,17 +73315,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RefinedTransition__ActionAssignment_5"
-    // InternalRoom.g:27101:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27148: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:27152:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27153:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27106:1: ( ruleDetailCode )
-            // InternalRoom.g:27107:1: ruleDetailCode
+            // InternalRoom.g:27153:1: ( ruleDetailCode )
+            // InternalRoom.g:27154:1: ruleDetailCode
             {
              before(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
             pushFollow(FOLLOW_2);
@@ -73200,21 +73356,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StateTerminal__StateAssignment"
-    // InternalRoom.g:27116:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27163: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:27167:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27168:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27121:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27122:1: ( RULE_ID )
+            // InternalRoom.g:27168:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27169:1: ( RULE_ID )
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); 
-            // InternalRoom.g:27123:1: ( RULE_ID )
-            // InternalRoom.g:27124:1: RULE_ID
+            // InternalRoom.g:27170:1: ( RULE_ID )
+            // InternalRoom.g:27171:1: RULE_ID
             {
              before(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73245,21 +73401,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__TrPointTerminal__TrPointAssignment_1"
-    // InternalRoom.g:27135:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27182: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:27186:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27187:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27140:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27141:1: ( RULE_ID )
+            // InternalRoom.g:27187:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27188:1: ( RULE_ID )
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); 
-            // InternalRoom.g:27142:1: ( RULE_ID )
-            // InternalRoom.g:27143:1: RULE_ID
+            // InternalRoom.g:27189:1: ( RULE_ID )
+            // InternalRoom.g:27190:1: RULE_ID
             {
              before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73290,21 +73446,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__TrPointAssignment_0"
-    // InternalRoom.g:27154:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27201: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:27205:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27206:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27159:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27160:1: ( RULE_ID )
+            // InternalRoom.g:27206:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27207:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); 
-            // InternalRoom.g:27161:1: ( RULE_ID )
-            // InternalRoom.g:27162:1: RULE_ID
+            // InternalRoom.g:27208:1: ( RULE_ID )
+            // InternalRoom.g:27209:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73335,21 +73491,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SubStateTrPointTerminal__StateAssignment_2"
-    // InternalRoom.g:27173:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27220: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:27224:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27225:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27178:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27179:1: ( RULE_ID )
+            // InternalRoom.g:27225:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27226:1: ( RULE_ID )
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); 
-            // InternalRoom.g:27180:1: ( RULE_ID )
-            // InternalRoom.g:27181:1: RULE_ID
+            // InternalRoom.g:27227:1: ( RULE_ID )
+            // InternalRoom.g:27228:1: RULE_ID
             {
              before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73380,21 +73536,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ChoicepointTerminal__CpAssignment_1"
-    // InternalRoom.g:27192:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27239: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:27243:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27244:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27197:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27198:1: ( RULE_ID )
+            // InternalRoom.g:27244:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27245:1: ( RULE_ID )
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); 
-            // InternalRoom.g:27199:1: ( RULE_ID )
-            // InternalRoom.g:27200:1: RULE_ID
+            // InternalRoom.g:27246:1: ( RULE_ID )
+            // InternalRoom.g:27247:1: RULE_ID
             {
              before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73425,17 +73581,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_1"
-    // InternalRoom.g:27211:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ;
+    // InternalRoom.g:27258: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:27262:1: ( ( ruleMessageFromIf ) )
+            // InternalRoom.g:27263:1: ( ruleMessageFromIf )
             {
-            // InternalRoom.g:27216:1: ( ruleMessageFromIf )
-            // InternalRoom.g:27217:1: ruleMessageFromIf
+            // InternalRoom.g:27263:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27264:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73466,17 +73622,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:27273: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:27277:1: ( ( ruleMessageFromIf ) )
+            // InternalRoom.g:27278:1: ( ruleMessageFromIf )
             {
-            // InternalRoom.g:27231:1: ( ruleMessageFromIf )
-            // InternalRoom.g:27232:1: ruleMessageFromIf
+            // InternalRoom.g:27278:1: ( ruleMessageFromIf )
+            // InternalRoom.g:27279:1: ruleMessageFromIf
             {
              before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73507,17 +73663,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Trigger__GuardAssignment_3"
-    // InternalRoom.g:27241:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ;
+    // InternalRoom.g:27288: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:27292:1: ( ( ruleGuard ) )
+            // InternalRoom.g:27293:1: ( ruleGuard )
             {
-            // InternalRoom.g:27246:1: ( ruleGuard )
-            // InternalRoom.g:27247:1: ruleGuard
+            // InternalRoom.g:27293:1: ( ruleGuard )
+            // InternalRoom.g:27294:1: ruleGuard
             {
              before(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -73548,21 +73704,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__MessageAssignment_0"
-    // InternalRoom.g:27256:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27303: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:27307:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27308:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27261:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27262:1: ( RULE_ID )
+            // InternalRoom.g:27308:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27309:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); 
-            // InternalRoom.g:27263:1: ( RULE_ID )
-            // InternalRoom.g:27264:1: RULE_ID
+            // InternalRoom.g:27310:1: ( RULE_ID )
+            // InternalRoom.g:27311:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73593,21 +73749,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__MessageFromIf__FromAssignment_2"
-    // InternalRoom.g:27275:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27322: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:27326:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27327:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27280:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27281:1: ( RULE_ID )
+            // InternalRoom.g:27327:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27328:1: ( RULE_ID )
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); 
-            // InternalRoom.g:27282:1: ( RULE_ID )
-            // InternalRoom.g:27283:1: RULE_ID
+            // InternalRoom.g:27329:1: ( RULE_ID )
+            // InternalRoom.g:27330:1: RULE_ID
             {
              before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73638,17 +73794,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Guard__GuardAssignment_1"
-    // InternalRoom.g:27294:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ;
+    // InternalRoom.g:27341: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:27345:1: ( ( ruleDetailCode ) )
+            // InternalRoom.g:27346:1: ( ruleDetailCode )
             {
-            // InternalRoom.g:27299:1: ( ruleDetailCode )
-            // InternalRoom.g:27300:1: ruleDetailCode
+            // InternalRoom.g:27346:1: ( ruleDetailCode )
+            // InternalRoom.g:27347:1: ruleDetailCode
             {
              before(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73679,17 +73835,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__ProtocolSemantics__RulesAssignment_3"
-    // InternalRoom.g:27309:1: rule__ProtocolSemantics__RulesAssignment_3 : ( ruleSemanticsRule ) ;
+    // InternalRoom.g:27356: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:27360:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27361:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27314:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27315:1: ruleSemanticsRule
+            // InternalRoom.g:27361:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27362:1: ruleSemanticsRule
             {
              before(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); 
             pushFollow(FOLLOW_2);
@@ -73720,21 +73876,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__InSemanticsRule__MsgAssignment_2"
-    // InternalRoom.g:27324:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27371: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:27375:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27376:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27329:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27330:1: ( RULE_ID )
+            // InternalRoom.g:27376:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27377:1: ( RULE_ID )
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalRoom.g:27331:1: ( RULE_ID )
-            // InternalRoom.g:27332:1: RULE_ID
+            // InternalRoom.g:27378:1: ( RULE_ID )
+            // InternalRoom.g:27379:1: RULE_ID
             {
              before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73765,17 +73921,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:27390: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:27394:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27395:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27348:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27349:1: ruleSemanticsRule
+            // InternalRoom.g:27395:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27396:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -73806,17 +73962,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:27405: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:27409:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27410:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27363:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27364:1: ruleSemanticsRule
+            // InternalRoom.g:27410:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27411:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73847,17 +74003,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:27420: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:27424:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27425:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27378:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27379:1: ruleSemanticsRule
+            // InternalRoom.g:27425:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27426:1: ruleSemanticsRule
             {
              before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -73888,21 +74044,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__OutSemanticsRule__MsgAssignment_2"
-    // InternalRoom.g:27388:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ;
+    // InternalRoom.g:27435: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:27439:1: ( ( ( RULE_ID ) ) )
+            // InternalRoom.g:27440:1: ( ( RULE_ID ) )
             {
-            // InternalRoom.g:27393:1: ( ( RULE_ID ) )
-            // InternalRoom.g:27394:1: ( RULE_ID )
+            // InternalRoom.g:27440:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27441:1: ( RULE_ID )
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); 
-            // InternalRoom.g:27395:1: ( RULE_ID )
-            // InternalRoom.g:27396:1: RULE_ID
+            // InternalRoom.g:27442:1: ( RULE_ID )
+            // InternalRoom.g:27443:1: RULE_ID
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -73933,17 +74089,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:27454: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:27458:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27459:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27412:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27413:1: ruleSemanticsRule
+            // InternalRoom.g:27459:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27460:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
             pushFollow(FOLLOW_2);
@@ -73974,17 +74130,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:27469: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:27473:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27474:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27427:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27428:1: ruleSemanticsRule
+            // InternalRoom.g:27474:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27475:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74015,17 +74171,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:27484: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:27488:1: ( ( ruleSemanticsRule ) )
+            // InternalRoom.g:27489:1: ( ruleSemanticsRule )
             {
-            // InternalRoom.g:27442:1: ( ruleSemanticsRule )
-            // InternalRoom.g:27443:1: ruleSemanticsRule
+            // InternalRoom.g:27489:1: ( ruleSemanticsRule )
+            // InternalRoom.g:27490:1: ruleSemanticsRule
             {
              before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74056,21 +74212,21 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Annotation__TypeAssignment_1"
-    // InternalRoom.g:27452:1: rule__Annotation__TypeAssignment_1 : ( ( ruleFQN ) ) ;
+    // InternalRoom.g:27499: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:27503:1: ( ( ( ruleFQN ) ) )
+            // InternalRoom.g:27504:1: ( ( ruleFQN ) )
             {
-            // InternalRoom.g:27457:1: ( ( ruleFQN ) )
-            // InternalRoom.g:27458:1: ( ruleFQN )
+            // InternalRoom.g:27504:1: ( ( ruleFQN ) )
+            // InternalRoom.g:27505:1: ( ruleFQN )
             {
              before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeCrossReference_1_0()); 
-            // InternalRoom.g:27459:1: ( ruleFQN )
-            // InternalRoom.g:27460:1: ruleFQN
+            // InternalRoom.g:27506:1: ( ruleFQN )
+            // InternalRoom.g:27507:1: ruleFQN
             {
              before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeFQNParserRuleCall_1_0_1()); 
             pushFollow(FOLLOW_2);
@@ -74105,17 +74261,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:27518: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:27522:1: ( ( ruleKeyValue ) )
+            // InternalRoom.g:27523:1: ( ruleKeyValue )
             {
-            // InternalRoom.g:27476:1: ( ruleKeyValue )
-            // InternalRoom.g:27477:1: ruleKeyValue
+            // InternalRoom.g:27523:1: ( ruleKeyValue )
+            // InternalRoom.g:27524:1: ruleKeyValue
             {
              before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74146,17 +74302,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:27533: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:27537:1: ( ( ruleKeyValue ) )
+            // InternalRoom.g:27538:1: ( ruleKeyValue )
             {
-            // InternalRoom.g:27491:1: ( ruleKeyValue )
-            // InternalRoom.g:27492:1: ruleKeyValue
+            // InternalRoom.g:27538:1: ( ruleKeyValue )
+            // InternalRoom.g:27539:1: ruleKeyValue
             {
              before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74187,17 +74343,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__KeyAssignment_0"
-    // InternalRoom.g:27501:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ;
+    // InternalRoom.g:27548: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:27552:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27553:1: ( RULE_ID )
             {
-            // InternalRoom.g:27506:1: ( RULE_ID )
-            // InternalRoom.g:27507:1: RULE_ID
+            // InternalRoom.g:27553:1: ( RULE_ID )
+            // InternalRoom.g:27554:1: RULE_ID
             {
              before(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74224,17 +74380,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__KeyValue__ValueAssignment_2"
-    // InternalRoom.g:27516:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ;
+    // InternalRoom.g:27563: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:27567:1: ( ( ruleLiteral ) )
+            // InternalRoom.g:27568:1: ( ruleLiteral )
             {
-            // InternalRoom.g:27521:1: ( ruleLiteral )
-            // InternalRoom.g:27522:1: ruleLiteral
+            // InternalRoom.g:27568:1: ( ruleLiteral )
+            // InternalRoom.g:27569:1: ruleLiteral
             {
              before(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -74265,17 +74421,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__NameAssignment_1"
-    // InternalRoom.g:27531:1: rule__AnnotationType__NameAssignment_1 : ( RULE_ID ) ;
+    // InternalRoom.g:27578: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:27582:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27583:1: ( RULE_ID )
             {
-            // InternalRoom.g:27536:1: ( RULE_ID )
-            // InternalRoom.g:27537:1: RULE_ID
+            // InternalRoom.g:27583:1: ( RULE_ID )
+            // InternalRoom.g:27584:1: RULE_ID
             {
              before(grammarAccess.getAnnotationTypeAccess().getNameIDTerminalRuleCall_1_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74302,17 +74458,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__DocuAssignment_2"
-    // InternalRoom.g:27546:1: rule__AnnotationType__DocuAssignment_2 : ( ruleDocumentation ) ;
+    // InternalRoom.g:27593: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:27597:1: ( ( ruleDocumentation ) )
+            // InternalRoom.g:27598:1: ( ruleDocumentation )
             {
-            // InternalRoom.g:27551:1: ( ruleDocumentation )
-            // InternalRoom.g:27552:1: ruleDocumentation
+            // InternalRoom.g:27598:1: ( ruleDocumentation )
+            // InternalRoom.g:27599:1: ruleDocumentation
             {
              before(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
             pushFollow(FOLLOW_2);
@@ -74343,17 +74499,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:27608: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:27612:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27613:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27566:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27567:1: ruleAnnotationTargetType
+            // InternalRoom.g:27613:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27614:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); 
             pushFollow(FOLLOW_2);
@@ -74384,17 +74540,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:27623: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:27627:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27628:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27581:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27582:1: ruleAnnotationTargetType
+            // InternalRoom.g:27628:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27629:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74425,17 +74581,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:27638: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:27642:1: ( ( ruleAnnotationTargetType ) )
+            // InternalRoom.g:27643:1: ( ruleAnnotationTargetType )
             {
-            // InternalRoom.g:27596:1: ( ruleAnnotationTargetType )
-            // InternalRoom.g:27597:1: ruleAnnotationTargetType
+            // InternalRoom.g:27643:1: ( ruleAnnotationTargetType )
+            // InternalRoom.g:27644:1: ruleAnnotationTargetType
             {
              before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74466,17 +74622,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__AnnotationType__AttributesAssignment_7"
-    // InternalRoom.g:27606:1: rule__AnnotationType__AttributesAssignment_7 : ( ruleAnnotationAttribute ) ;
+    // InternalRoom.g:27653: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:27657:1: ( ( ruleAnnotationAttribute ) )
+            // InternalRoom.g:27658:1: ( ruleAnnotationAttribute )
             {
-            // InternalRoom.g:27611:1: ( ruleAnnotationAttribute )
-            // InternalRoom.g:27612:1: ruleAnnotationAttribute
+            // InternalRoom.g:27658:1: ( ruleAnnotationAttribute )
+            // InternalRoom.g:27659:1: ruleAnnotationAttribute
             {
              before(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); 
             pushFollow(FOLLOW_2);
@@ -74507,21 +74663,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:27668: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:27672:1: ( ( ( 'optional' ) ) )
+            // InternalRoom.g:27673:1: ( ( 'optional' ) )
             {
-            // InternalRoom.g:27626:1: ( ( 'optional' ) )
-            // InternalRoom.g:27627:1: ( 'optional' )
+            // InternalRoom.g:27673:1: ( ( 'optional' ) )
+            // InternalRoom.g:27674:1: ( 'optional' )
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalRoom.g:27628:1: ( 'optional' )
-            // InternalRoom.g:27629:1: 'optional'
+            // InternalRoom.g:27675:1: ( 'optional' )
+            // InternalRoom.g:27676:1: 'optional'
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,37,FOLLOW_2); 
@@ -74552,17 +74708,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__NameAssignment_2"
-    // InternalRoom.g:27644:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:27691: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:27695:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27696:1: ( RULE_ID )
             {
-            // InternalRoom.g:27649:1: ( RULE_ID )
-            // InternalRoom.g:27650:1: RULE_ID
+            // InternalRoom.g:27696:1: ( RULE_ID )
+            // InternalRoom.g:27697:1: RULE_ID
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74589,17 +74745,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__SimpleAnnotationAttribute__TypeAssignment_4"
-    // InternalRoom.g:27659:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ;
+    // InternalRoom.g:27706: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:27710:1: ( ( ruleLiteralType ) )
+            // InternalRoom.g:27711:1: ( ruleLiteralType )
             {
-            // InternalRoom.g:27664:1: ( ruleLiteralType )
-            // InternalRoom.g:27665:1: ruleLiteralType
+            // InternalRoom.g:27711:1: ( ruleLiteralType )
+            // InternalRoom.g:27712:1: ruleLiteralType
             {
              before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
             pushFollow(FOLLOW_2);
@@ -74630,21 +74786,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:27721: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:27725:1: ( ( ( 'optional' ) ) )
+            // InternalRoom.g:27726:1: ( ( 'optional' ) )
             {
-            // InternalRoom.g:27679:1: ( ( 'optional' ) )
-            // InternalRoom.g:27680:1: ( 'optional' )
+            // InternalRoom.g:27726:1: ( ( 'optional' ) )
+            // InternalRoom.g:27727:1: ( 'optional' )
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
-            // InternalRoom.g:27681:1: ( 'optional' )
-            // InternalRoom.g:27682:1: 'optional'
+            // InternalRoom.g:27728:1: ( 'optional' )
+            // InternalRoom.g:27729:1: 'optional'
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); 
             match(input,37,FOLLOW_2); 
@@ -74675,17 +74831,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__NameAssignment_2"
-    // InternalRoom.g:27697:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ;
+    // InternalRoom.g:27744: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:27748:1: ( ( RULE_ID ) )
+            // InternalRoom.g:27749:1: ( RULE_ID )
             {
-            // InternalRoom.g:27702:1: ( RULE_ID )
-            // InternalRoom.g:27703:1: RULE_ID
+            // InternalRoom.g:27749:1: ( RULE_ID )
+            // InternalRoom.g:27750:1: RULE_ID
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); 
             match(input,RULE_ID,FOLLOW_2); 
@@ -74712,17 +74868,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_5"
-    // InternalRoom.g:27712:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ;
+    // InternalRoom.g:27759: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:27763:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27764:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27717:1: ( RULE_STRING )
-            // InternalRoom.g:27718:1: RULE_STRING
+            // InternalRoom.g:27764:1: ( RULE_STRING )
+            // InternalRoom.g:27765:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74749,17 +74905,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:27774: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:27778:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27779:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27732:1: ( RULE_STRING )
-            // InternalRoom.g:27733:1: RULE_STRING
+            // InternalRoom.g:27779:1: ( RULE_STRING )
+            // InternalRoom.g:27780:1: RULE_STRING
             {
              before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74786,17 +74942,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:27789: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:27793:1: ( ( ruleImportedFQN ) )
+            // InternalRoom.g:27794:1: ( ruleImportedFQN )
             {
-            // InternalRoom.g:27747:1: ( ruleImportedFQN )
-            // InternalRoom.g:27748:1: ruleImportedFQN
+            // InternalRoom.g:27794:1: ( ruleImportedFQN )
+            // InternalRoom.g:27795:1: ruleImportedFQN
             {
              before(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); 
             pushFollow(FOLLOW_2);
@@ -74827,17 +74983,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Import__ImportURIAssignment_2"
-    // InternalRoom.g:27757:1: rule__Import__ImportURIAssignment_2 : ( RULE_STRING ) ;
+    // InternalRoom.g:27804: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:27808:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27809:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27762:1: ( RULE_STRING )
-            // InternalRoom.g:27763:1: RULE_STRING
+            // InternalRoom.g:27809:1: ( RULE_STRING )
+            // InternalRoom.g:27810:1: RULE_STRING
             {
              before(grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_2_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74864,17 +75020,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__Documentation__LinesAssignment_2"
-    // InternalRoom.g:27772:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ;
+    // InternalRoom.g:27819: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:27823:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27824:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27777:1: ( RULE_STRING )
-            // InternalRoom.g:27778:1: RULE_STRING
+            // InternalRoom.g:27824:1: ( RULE_STRING )
+            // InternalRoom.g:27825:1: RULE_STRING
             {
              before(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -74901,21 +75057,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:27836: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:27840:1: ( ( ( 'true' ) ) )
+            // InternalRoom.g:27841:1: ( ( 'true' ) )
             {
-            // InternalRoom.g:27794:1: ( ( 'true' ) )
-            // InternalRoom.g:27795:1: ( 'true' )
+            // InternalRoom.g:27841:1: ( ( 'true' ) )
+            // InternalRoom.g:27842:1: ( 'true' )
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
-            // InternalRoom.g:27796:1: ( 'true' )
-            // InternalRoom.g:27797:1: 'true'
+            // InternalRoom.g:27843:1: ( 'true' )
+            // InternalRoom.g:27844:1: 'true'
             {
              before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
             match(input,132,FOLLOW_2); 
@@ -74946,17 +75102,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__RealLiteral__ValueAssignment_1"
-    // InternalRoom.g:27812:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ;
+    // InternalRoom.g:27859: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:27863:1: ( ( ruleReal ) )
+            // InternalRoom.g:27864:1: ( ruleReal )
             {
-            // InternalRoom.g:27817:1: ( ruleReal )
-            // InternalRoom.g:27818:1: ruleReal
+            // InternalRoom.g:27864:1: ( ruleReal )
+            // InternalRoom.g:27865:1: ruleReal
             {
              before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -74987,17 +75143,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__IntLiteral__ValueAssignment_1"
-    // InternalRoom.g:27827:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ;
+    // InternalRoom.g:27874: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:27878:1: ( ( ruleInteger ) )
+            // InternalRoom.g:27879:1: ( ruleInteger )
             {
-            // InternalRoom.g:27832:1: ( ruleInteger )
-            // InternalRoom.g:27833:1: ruleInteger
+            // InternalRoom.g:27879:1: ( ruleInteger )
+            // InternalRoom.g:27880:1: ruleInteger
             {
              before(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
             pushFollow(FOLLOW_2);
@@ -75028,17 +75184,17 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
 
 
     // $ANTLR start "rule__StringLiteral__ValueAssignment_1"
-    // InternalRoom.g:27842:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
+    // InternalRoom.g:27889: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:27893:1: ( ( RULE_STRING ) )
+            // InternalRoom.g:27894:1: ( RULE_STRING )
             {
-            // InternalRoom.g:27847:1: ( RULE_STRING )
-            // InternalRoom.g:27848:1: RULE_STRING
+            // InternalRoom.g:27894:1: ( RULE_STRING )
+            // InternalRoom.g:27895:1: RULE_STRING
             {
              before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); 
             match(input,RULE_STRING,FOLLOW_2); 
@@ -75067,8 +75223,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,42 +75267,42 @@ 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 "3082: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_11s = "\22\uffff\1\2\5\uffff\1\1\1\3";
+    static final String dfa_8s = "\14\uffff\1\21\6\uffff\2\21\1\uffff\1\21\2\uffff\1\21";
+    static final String dfa_9s = "\1\151\1\6\1\56\1\6\1\60\4\6\3\60\1\54\2\6\1\7\1\55\1\uffff\1\6\2\54\1\7\1\54\2\uffff\1\54";
+    static final String dfa_10s = "\1\151\2\56\1\162\1\65\3\6\1\162\3\60\1\u0083\2\6\1\77\1\157\1\uffff\1\6\2\u0083\1\77\1\u0083\2\uffff\1\u0083";
+    static final String dfa_11s = "\21\uffff\1\2\5\uffff\1\1\1\3\1\uffff";
     static final String dfa_12s = "\32\uffff}>";
     static final String[] dfa_13s = {
             "\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\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\13",
+            "\1\14\152\uffff\1\15\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
+            "\1\20\1\21\7\uffff\1\22\10\uffff\1\17\40\uffff\1\21\4\uffff\6\21\6\uffff\1\21\22\uffff\1\21",
             "\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",
+            "\1\25\67\uffff\1\26",
+            "\1\21\75\uffff\1\21\1\27\1\uffff\1\27\1\30",
             "",
-            "\1\21\1\22\20\uffff\1\20\40\uffff\1\22\4\uffff\6\22\6\uffff\1\22\22\uffff\1\22",
-            "\1\21\1\22\20\uffff\1\20\40\uffff\1\22\4\uffff\6\22\6\uffff\1\22\22\uffff\1\22",
-            "\1\21\1\22\20\uffff\1\20\40\uffff\1\22\4\uffff\6\22\6\uffff\1\22\22\uffff\1\22",
-            "\1\26\67\uffff\1\27",
-            "\1\21\1\22\61\uffff\1\22\4\uffff\6\22\6\uffff\1\22\22\uffff\1\22",
+            "\1\31",
+            "\1\20\1\21\20\uffff\1\17\40\uffff\1\21\4\uffff\6\21\6\uffff\1\21\22\uffff\1\21",
+            "\1\20\1\21\20\uffff\1\17\40\uffff\1\21\4\uffff\6\21\6\uffff\1\21\22\uffff\1\21",
+            "\1\25\67\uffff\1\26",
+            "\1\20\1\21\61\uffff\1\21\4\uffff\6\21\6\uffff\1\21\22\uffff\1\21",
             "",
-            ""
+            "",
+            "\1\20\1\21\20\uffff\1\17\40\uffff\1\21\4\uffff\6\21\6\uffff\1\21\22\uffff\1\21"
     };
 
     static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
@@ -75157,11 +75313,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,33 +75327,33 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_13;
         }
         public String getDescription() {
-            return "3955:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );";
+            return "4002: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\3\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\3\6\1\162\3\60\1\76\3\6\1\77\1\156\3\76\1\77\1\54\2\uffff";
+    static final String dfa_17s = "\27\uffff\1\2\1\1";
     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\13",
+            "\1\14\152\uffff\1\15\1\16",
+            "\1\10",
+            "\1\10",
+            "\1\10",
             "\1\21\10\uffff\1\17\10\uffff\1\20",
             "\1\22",
             "\1\23",
-            "\1\7",
             "\1\24",
             "\1\25\67\uffff\1\26",
-            "\1\27\1\uffff\1\30",
+            "\1\30\1\uffff\1\27",
             "\1\21\21\uffff\1\20",
             "\1\21\21\uffff\1\20",
             "\1\21\21\uffff\1\20",
@@ -75214,11 +75370,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 +75384,7 @@ public class InternalRoomParser extends AbstractInternalContentAssistParser {
             this.transition = dfa_19;
         }
         public String getDescription() {
-            return "3983:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
+            return "4030:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );";
         }
     }
  
diff --git a/plugins/org.eclipse.etrice.core.room.ui/xtend-gen/org/eclipse/etrice/core/ui/quickfix/DetailCodeIndentHelper.java b/plugins/org.eclipse.etrice.core.room.ui/xtend-gen/org/eclipse/etrice/core/ui/quickfix/DetailCodeIndentHelper.java
new file mode 100644
index 000000000..b934e19b5
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room.ui/xtend-gen/org/eclipse/etrice/core/ui/quickfix/DetailCodeIndentHelper.java
@@ -0,0 +1,90 @@
+package org.eclipse.etrice.core.ui.quickfix;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.ui.editor.model.IXtextDocument;
+import org.eclipse.xtext.util.Strings;
+import org.eclipse.xtext.validation.Issue;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IntegerRange;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure2;
+
+@SuppressWarnings("all")
+public class DetailCodeIndentHelper {
+  /**
+   * Converts the issued multi line string to single line strings
+   * - line with least indentation is adjusted to first line
+   * - lines are enclosed with " or '
+   * - lines get editor indentation of first line
+   * -
+   */
+  public static String convertToSingleLines(final IXtextDocument document, final Issue issue) {
+    try {
+      final IRegion issuedRegion = document.getLineInformationOfOffset((issue.getOffset()).intValue());
+      final String firstEditorLine = document.get(issuedRegion.getOffset(), issuedRegion.getLength());
+      final String editorIndent = Strings.getLeadingWhiteSpace(firstEditorLine);
+      final String editorString = document.get((issue.getOffset()).intValue(), (issue.getLength()).intValue());
+      final String mark = Character.valueOf(editorString.charAt(0)).toString();
+      final List<String> editorLines = Strings.split(editorString, Strings.newLine());
+      int _size = editorLines.size();
+      boolean _lessEqualsThan = (_size <= 1);
+      if (_lessEqualsThan) {
+        return editorString;
+      }
+      final Function1<String, Integer> _function = (String it) -> {
+        return Integer.valueOf(DetailCodeIndentHelper.countIndent(it));
+      };
+      final int minIndent = DetailCodeIndentHelper.countIndent(IterableExtensions.<String>head(IterableExtensions.<String, Integer>sortBy(IterableExtensions.<String>tail(editorLines), _function)));
+      final ArrayList<String> newEditorLines = new ArrayList<String>();
+      final Procedure2<String, Integer> _function_1 = (String line, Integer lineCount) -> {
+        String _xifexpression = null;
+        if (((lineCount).intValue() != 0)) {
+          _xifexpression = (editorIndent + mark);
+        }
+        String front = _xifexpression;
+        int _countIndent = DetailCodeIndentHelper.countIndent(line);
+        int indentCount = (_countIndent - minIndent);
+        String _xifexpression_1 = null;
+        if ((((lineCount).intValue() != 0) && (indentCount > 0))) {
+          StringConcatenation _builder = new StringConcatenation();
+          {
+            IntegerRange _upTo = new IntegerRange(1, indentCount);
+            for(final Integer i : _upTo) {
+              _builder.append("\t");
+            }
+          }
+          _xifexpression_1 = _builder.toString();
+        }
+        String indent = _xifexpression_1;
+        String noneWSLine = Strings.removeLeadingWhitespace(line);
+        String _xifexpression_2 = null;
+        int _size_1 = editorLines.size();
+        int _minus = (_size_1 - 1);
+        boolean _notEquals = ((lineCount).intValue() != _minus);
+        if (_notEquals) {
+          _xifexpression_2 = mark;
+        }
+        String end = _xifexpression_2;
+        StringConcatenation _builder_1 = new StringConcatenation();
+        _builder_1.append(front);
+        _builder_1.append(indent);
+        _builder_1.append(noneWSLine);
+        _builder_1.append(end);
+        String newEditorLine = _builder_1.toString();
+        newEditorLines.add(newEditorLine);
+      };
+      IterableExtensions.<String>forEach(editorLines, _function_1);
+      return Strings.concat(Strings.newLine(), newEditorLines);
+    } catch (Throwable _e) {
+      throw Exceptions.sneakyThrow(_e);
+    }
+  }
+  
+  private static int countIndent(final String line) {
+    return Strings.getLeadingWhiteSpace(line).replace("\t", "    ").replace("    ", "\t").replaceAll("!\\t", "").length();
+  }
+}
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 3bcc94e83..769e55efb 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.1",
  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.1"
 Import-Package: org.apache.log4j,
  org.eclipse.etrice.core.room
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
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..1720a6b00 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..b00ccc6fa 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
@@ -6119,6 +6119,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..3848f493d 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:9253:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ )
+            // InternalRoom.g:9253:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
             {
-            // InternalRoom.g:9215:12: ( '0x' | '0X' )
+            // InternalRoom.g:9253: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:9253:13: '0x'
                     {
                     match("0x"); 
 
@@ -2700,7 +2700,7 @@ public class InternalRoomLexer extends Lexer {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9215:18: '0X'
+                    // InternalRoom.g:9253: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:9253: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:9255:16: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' )
+            // InternalRoom.g:9255:18: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
             {
             match("'''"); 
 
-            // InternalRoom.g:9217:27: ( options {greedy=false; } : . )*
+            // InternalRoom.g:9255: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:9255: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:9257:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalRoom.g:9257:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
             {
-            // InternalRoom.g:9219:11: ( '^' )?
+            // InternalRoom.g:9257: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:9257: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:9257: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:9259:10: ( ( '0' .. '9' )+ )
+            // InternalRoom.g:9259:12: ( '0' .. '9' )+
             {
-            // InternalRoom.g:9221:12: ( '0' .. '9' )+
+            // InternalRoom.g:9259: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:9259: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:9261:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+            // InternalRoom.g:9261:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
             {
-            // InternalRoom.g:9223:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+            // InternalRoom.g:9261: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:9261:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
                     {
                     match('\"'); 
-                    // InternalRoom.g:9223:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    // InternalRoom.g:9261: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:9261:21: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3009,7 +3009,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:9223:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    // InternalRoom.g:9261: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:9261:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
                     {
                     match('\''); 
-                    // InternalRoom.g:9223:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    // InternalRoom.g:9261: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:9261:54: '\\\\' .
                     	    {
                     	    match('\\'); 
                     	    matchAny(); 
@@ -3061,7 +3061,7 @@ public class InternalRoomLexer extends Lexer {
                     	    }
                     	    break;
                     	case 2 :
-                    	    // InternalRoom.g:9223:61: ~ ( ( '\\\\' | '\\'' ) )
+                    	    // InternalRoom.g:9261: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:9263:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalRoom.g:9263:19: '/*' ( options {greedy=false; } : . )* '*/'
             {
             match("/*"); 
 
-            // InternalRoom.g:9225:24: ( options {greedy=false; } : . )*
+            // InternalRoom.g:9263: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:9263: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:9265:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalRoom.g:9265:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
             {
             match("//"); 
 
-            // InternalRoom.g:9227:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            // InternalRoom.g:9265: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:9265: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:9265: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:9265:41: ( '\\r' )? '\\n'
                     {
-                    // InternalRoom.g:9227:41: ( '\\r' )?
+                    // InternalRoom.g:9265: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:9265: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:9267:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalRoom.g:9267:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
             {
-            // InternalRoom.g:9229:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            // InternalRoom.g:9267: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:9269:16: ( . )
+            // InternalRoom.g:9269: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..a0e889435 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
@@ -15258,8 +15258,133 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
     // $ANTLR end "ruleChoicePoint"
 
 
+    // $ANTLR start "entryRuleTransitionBase"
+    // InternalRoom.g:6123: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:6124:2: (iv_ruleTransitionBase= ruleTransitionBase EOF )
+            // InternalRoom.g:6125: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:6132: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:6135:28: ( (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition ) )
+            // InternalRoom.g:6136:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            {
+            // InternalRoom.g:6136:1: (this_Transition_0= ruleTransition | this_RefinedTransition_1= ruleRefinedTransition )
+            int alt131=2;
+            int LA131_0 = input.LA(1);
+
+            if ( (LA131_0==92) ) {
+                alt131=1;
+            }
+            else if ( (LA131_0==99) ) {
+                alt131=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 131, 0, input);
+
+                throw nvae;
+            }
+            switch (alt131) {
+                case 1 :
+                    // InternalRoom.g:6137: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:6147: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:6163:1: entryRuleTransition returns [EObject current=null] : iv_ruleTransition= ruleTransition EOF ;
     public final EObject entryRuleTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15267,8 +15392,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:6164:2: (iv_ruleTransition= ruleTransition EOF )
+            // InternalRoom.g:6165:2: iv_ruleTransition= ruleTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15295,7 +15420,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:6172: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 +15432,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:6175:28: ( (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition ) )
+            // InternalRoom.g:6176: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:6176:1: (this_InitialTransition_0= ruleInitialTransition | this_NonInitialTransition_1= ruleNonInitialTransition )
+            int alt132=2;
+            int LA132_0 = input.LA(1);
 
-            if ( (LA131_0==92) ) {
-                int LA131_1 = input.LA(2);
+            if ( (LA132_0==92) ) {
+                int LA132_1 = input.LA(2);
 
-                if ( (LA131_1==RULE_ID) ) {
-                    int LA131_2 = input.LA(3);
+                if ( (LA132_1==RULE_ID) ) {
+                    int LA132_2 = input.LA(3);
 
-                    if ( (LA131_2==16) ) {
-                        int LA131_3 = input.LA(4);
+                    if ( (LA132_2==16) ) {
+                        int LA132_3 = input.LA(4);
 
-                        if ( (LA131_3==93) ) {
-                            alt131=1;
+                        if ( (LA132_3==RULE_ID||(LA132_3>=100 && LA132_3<=101)) ) {
+                            alt132=2;
                         }
-                        else if ( (LA131_3==RULE_ID||(LA131_3>=100 && LA131_3<=101)) ) {
-                            alt131=2;
+                        else if ( (LA132_3==93) ) {
+                            alt132=1;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 131, 3, input);
+                                new NoViableAltException("", 132, 3, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 131, 2, input);
+                            new NoViableAltException("", 132, 2, input);
 
                         throw nvae;
                     }
                 }
-                else if ( (LA131_1==16) ) {
-                    int LA131_3 = input.LA(3);
+                else if ( (LA132_1==16) ) {
+                    int LA132_3 = input.LA(3);
 
-                    if ( (LA131_3==93) ) {
-                        alt131=1;
+                    if ( (LA132_3==RULE_ID||(LA132_3>=100 && LA132_3<=101)) ) {
+                        alt132=2;
                     }
-                    else if ( (LA131_3==RULE_ID||(LA131_3>=100 && LA131_3<=101)) ) {
-                        alt131=2;
+                    else if ( (LA132_3==93) ) {
+                        alt132=1;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 131, 3, input);
+                            new NoViableAltException("", 132, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 131, 1, input);
+                        new NoViableAltException("", 132, 1, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 131, 0, input);
+                    new NoViableAltException("", 132, 0, input);
 
                 throw nvae;
             }
-            switch (alt131) {
+            switch (alt132) {
                 case 1 :
-                    // InternalRoom.g:6139:5: this_InitialTransition_0= ruleInitialTransition
+                    // InternalRoom.g:6177:5: this_InitialTransition_0= ruleInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); 
@@ -15392,7 +15517,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6149:5: this_NonInitialTransition_1= ruleNonInitialTransition
+                    // InternalRoom.g:6187:5: this_NonInitialTransition_1= ruleNonInitialTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); 
@@ -15430,7 +15555,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNonInitialTransition"
-    // InternalRoom.g:6165:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
+    // InternalRoom.g:6203:1: entryRuleNonInitialTransition returns [EObject current=null] : iv_ruleNonInitialTransition= ruleNonInitialTransition EOF ;
     public final EObject entryRuleNonInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15438,8 +15563,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:6204:2: (iv_ruleNonInitialTransition= ruleNonInitialTransition EOF )
+            // InternalRoom.g:6205:2: iv_ruleNonInitialTransition= ruleNonInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getNonInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15466,7 +15591,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:6212: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 +15605,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:6215:28: ( (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition ) )
+            // InternalRoom.g:6216: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:6216:1: (this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition | this_ContinuationTransition_1= ruleContinuationTransition | this_CPBranchTransition_2= ruleCPBranchTransition )
+            int alt133=3;
+            alt133 = dfa133.predict(input);
+            switch (alt133) {
                 case 1 :
-                    // InternalRoom.g:6179:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
+                    // InternalRoom.g:6217:5: this_TransitionChainStartTransition_0= ruleTransitionChainStartTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); 
@@ -15506,7 +15631,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6189:5: this_ContinuationTransition_1= ruleContinuationTransition
+                    // InternalRoom.g:6227:5: this_ContinuationTransition_1= ruleContinuationTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); 
@@ -15524,7 +15649,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:6199:5: this_CPBranchTransition_2= ruleCPBranchTransition
+                    // InternalRoom.g:6237:5: this_CPBranchTransition_2= ruleCPBranchTransition
                     {
                      
                             newCompositeNode(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); 
@@ -15562,7 +15687,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionChainStartTransition"
-    // InternalRoom.g:6215:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
+    // InternalRoom.g:6253:1: entryRuleTransitionChainStartTransition returns [EObject current=null] : iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF ;
     public final EObject entryRuleTransitionChainStartTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15570,8 +15695,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:6254:2: (iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF )
+            // InternalRoom.g:6255:2: iv_ruleTransitionChainStartTransition= ruleTransitionChainStartTransition EOF
             {
              newCompositeNode(grammarAccess.getTransitionChainStartTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15598,7 +15723,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:6262: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 +15735,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:6265:28: ( (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition ) )
+            // InternalRoom.g:6266: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:6266:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )
+            int alt134=2;
+            alt134 = dfa134.predict(input);
+            switch (alt134) {
                 case 1 :
-                    // InternalRoom.g:6229:5: this_TriggeredTransition_0= ruleTriggeredTransition
+                    // InternalRoom.g:6267:5: this_TriggeredTransition_0= ruleTriggeredTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); 
@@ -15636,7 +15761,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:6239:5: this_GuardedTransition_1= ruleGuardedTransition
+                    // InternalRoom.g:6277:5: this_GuardedTransition_1= ruleGuardedTransition
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); 
@@ -15674,7 +15799,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInitialTransition"
-    // InternalRoom.g:6255:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
+    // InternalRoom.g:6293:1: entryRuleInitialTransition returns [EObject current=null] : iv_ruleInitialTransition= ruleInitialTransition EOF ;
     public final EObject entryRuleInitialTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15682,8 +15807,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:6294:2: (iv_ruleInitialTransition= ruleInitialTransition EOF )
+            // InternalRoom.g:6295:2: iv_ruleInitialTransition= ruleInitialTransition EOF
             {
              newCompositeNode(grammarAccess.getInitialTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15710,7 +15835,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:6302: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 +15857,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:6305: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:6306: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:6306: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:6306: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); 
 
                 	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:6310:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt135=2;
+            int LA135_0 = input.LA(1);
 
-            if ( (LA134_0==RULE_ID) ) {
-                alt134=1;
+            if ( (LA135_0==RULE_ID) ) {
+                alt135=1;
             }
-            switch (alt134) {
+            switch (alt135) {
                 case 1 :
-                    // InternalRoom.g:6273:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6311: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:6311:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6312:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -15791,11 +15916,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6340:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6341: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:6341:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6342:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -15822,19 +15947,19 @@ 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:6358:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt136=2;
+            int LA136_0 = input.LA(1);
 
-            if ( (LA135_0==34) ) {
-                alt135=1;
+            if ( (LA136_0==34) ) {
+                alt136=1;
             }
-            switch (alt135) {
+            switch (alt136) {
                 case 1 :
-                    // InternalRoom.g:6321:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6359: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:6359:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6360:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -15864,41 +15989,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:6376:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt138=2;
+            int LA138_0 = input.LA(1);
 
-            if ( (LA137_0==14) ) {
-                alt137=1;
+            if ( (LA138_0==14) ) {
+                alt138=1;
             }
-            switch (alt137) {
+            switch (alt138) {
                 case 1 :
-                    // InternalRoom.g:6338:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalRoom.g:6376:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
                     otherlv_7=(Token)match(input,14,FOLLOW_121); 
 
                         	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:6380:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt137=2;
+                    int LA137_0 = input.LA(1);
 
-                    if ( (LA136_0==94) ) {
-                        alt136=1;
+                    if ( (LA137_0==94) ) {
+                        alt137=1;
                     }
-                    switch (alt136) {
+                    switch (alt137) {
                         case 1 :
-                            // InternalRoom.g:6342:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6380:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
                             otherlv_8=(Token)match(input,94,FOLLOW_122); 
 
                                 	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:6384:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6385: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:6385:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6386:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -15962,7 +16087,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleContinuationTransition"
-    // InternalRoom.g:6376:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
+    // InternalRoom.g:6414:1: entryRuleContinuationTransition returns [EObject current=null] : iv_ruleContinuationTransition= ruleContinuationTransition EOF ;
     public final EObject entryRuleContinuationTransition() throws RecognitionException {
         EObject current = null;
 
@@ -15970,8 +16095,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:6415:2: (iv_ruleContinuationTransition= ruleContinuationTransition EOF )
+            // InternalRoom.g:6416:2: iv_ruleContinuationTransition= ruleContinuationTransition EOF
             {
              newCompositeNode(grammarAccess.getContinuationTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -15998,7 +16123,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:6423: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 +16146,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:6426: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:6427: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:6427: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:6427: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); 
 
                 	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:6431:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt139=2;
+            int LA139_0 = input.LA(1);
 
-            if ( (LA138_0==RULE_ID) ) {
-                alt138=1;
+            if ( (LA139_0==RULE_ID) ) {
+                alt139=1;
             }
-            switch (alt138) {
+            switch (alt139) {
                 case 1 :
-                    // InternalRoom.g:6394:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6432: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:6432:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6433:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16072,11 +16197,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6453:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6454: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:6454:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6455:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16107,11 +16232,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6475:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6476: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:6476:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6477:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -16138,19 +16263,19 @@ 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:6493:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt140=2;
+            int LA140_0 = input.LA(1);
 
-            if ( (LA139_0==34) ) {
-                alt139=1;
+            if ( (LA140_0==34) ) {
+                alt140=1;
             }
-            switch (alt139) {
+            switch (alt140) {
                 case 1 :
-                    // InternalRoom.g:6456:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6494: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:6494:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6495:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -16180,41 +16305,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:6511:3: (otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}' )?
+            int alt142=2;
+            int LA142_0 = input.LA(1);
 
-            if ( (LA141_0==14) ) {
-                alt141=1;
+            if ( (LA142_0==14) ) {
+                alt142=1;
             }
-            switch (alt141) {
+            switch (alt142) {
                 case 1 :
-                    // InternalRoom.g:6473:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
+                    // InternalRoom.g:6511:5: otherlv_7= '{' (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )? otherlv_10= '}'
                     {
                     otherlv_7=(Token)match(input,14,FOLLOW_121); 
 
                         	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:6515:1: (otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) ) )?
+                    int alt141=2;
+                    int LA141_0 = input.LA(1);
 
-                    if ( (LA140_0==94) ) {
-                        alt140=1;
+                    if ( (LA141_0==94) ) {
+                        alt141=1;
                     }
-                    switch (alt140) {
+                    switch (alt141) {
                         case 1 :
-                            // InternalRoom.g:6477:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6515:3: otherlv_8= 'action' ( (lv_action_9_0= ruleDetailCode ) )
                             {
                             otherlv_8=(Token)match(input,94,FOLLOW_122); 
 
                                 	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:6519:1: ( (lv_action_9_0= ruleDetailCode ) )
+                            // InternalRoom.g:6520: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:6520:1: (lv_action_9_0= ruleDetailCode )
+                            // InternalRoom.g:6521:3: lv_action_9_0= ruleDetailCode
                             {
                              
                             	        newCompositeNode(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); 
@@ -16278,7 +16403,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTriggeredTransition"
-    // InternalRoom.g:6511:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
+    // InternalRoom.g:6549:1: entryRuleTriggeredTransition returns [EObject current=null] : iv_ruleTriggeredTransition= ruleTriggeredTransition EOF ;
     public final EObject entryRuleTriggeredTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16286,8 +16411,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:6550:2: (iv_ruleTriggeredTransition= ruleTriggeredTransition EOF )
+            // InternalRoom.g:6551:2: iv_ruleTriggeredTransition= ruleTriggeredTransition EOF
             {
              newCompositeNode(grammarAccess.getTriggeredTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -16314,7 +16439,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:6558: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 +16470,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:6561: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:6562: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:6562: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:6562: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); 
 
                 	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:6566:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt143=2;
+            int LA143_0 = input.LA(1);
 
-            if ( (LA142_0==RULE_ID) ) {
-                alt142=1;
+            if ( (LA143_0==RULE_ID) ) {
+                alt143=1;
             }
-            switch (alt142) {
+            switch (alt143) {
                 case 1 :
-                    // InternalRoom.g:6529:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6567: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:6567:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6568:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16396,11 +16521,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6588:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6589: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:6589:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6590:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16431,11 +16556,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6610:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6611: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:6611:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6612:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -16462,19 +16587,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:6628:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt144=2;
+            int LA144_0 = input.LA(1);
 
-            if ( (LA143_0==34) ) {
-                alt143=1;
+            if ( (LA144_0==34) ) {
+                alt144=1;
             }
-            switch (alt143) {
+            switch (alt144) {
                 case 1 :
-                    // InternalRoom.g:6591:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6629: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:6629:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6630:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -16516,11 +16641,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6658:1: ( (lv_triggers_10_0= ruleTrigger ) )
+            // InternalRoom.g:6659: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:6659:1: (lv_triggers_10_0= ruleTrigger )
+            // InternalRoom.g:6660:3: lv_triggers_10_0= ruleTrigger
             {
              
             	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); 
@@ -16547,30 +16672,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:6638:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
-            loop144:
+            // InternalRoom.g:6676:2: (otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) ) )*
+            loop145:
             do {
-                int alt144=2;
-                int LA144_0 = input.LA(1);
+                int alt145=2;
+                int LA145_0 = input.LA(1);
 
-                if ( (LA144_0==96) ) {
-                    alt144=1;
+                if ( (LA145_0==96) ) {
+                    alt145=1;
                 }
 
 
-                switch (alt144) {
+                switch (alt145) {
             	case 1 :
-            	    // InternalRoom.g:6638:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalRoom.g:6676:4: otherlv_11= 'or' ( (lv_triggers_12_0= ruleTrigger ) )
             	    {
             	    otherlv_11=(Token)match(input,96,FOLLOW_124); 
 
             	        	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:6680:1: ( (lv_triggers_12_0= ruleTrigger ) )
+            	    // InternalRoom.g:6681: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:6681:1: (lv_triggers_12_0= ruleTrigger )
+            	    // InternalRoom.g:6682:3: lv_triggers_12_0= ruleTrigger
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); 
@@ -16602,7 +16727,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop144;
+            	    break loop145;
                 }
             } while (true);
 
@@ -16610,26 +16735,26 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6702:1: (otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) ) )?
+            int alt146=2;
+            int LA146_0 = input.LA(1);
 
-            if ( (LA145_0==94) ) {
-                alt145=1;
+            if ( (LA146_0==94) ) {
+                alt146=1;
             }
-            switch (alt145) {
+            switch (alt146) {
                 case 1 :
-                    // InternalRoom.g:6664:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalRoom.g:6702:3: otherlv_14= 'action' ( (lv_action_15_0= ruleDetailCode ) )
                     {
                     otherlv_14=(Token)match(input,94,FOLLOW_122); 
 
                         	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:6706:1: ( (lv_action_15_0= ruleDetailCode ) )
+                    // InternalRoom.g:6707: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:6707:1: (lv_action_15_0= ruleDetailCode )
+                    // InternalRoom.g:6708:3: lv_action_15_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); 
@@ -16687,7 +16812,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuardedTransition"
-    // InternalRoom.g:6698:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
+    // InternalRoom.g:6736:1: entryRuleGuardedTransition returns [EObject current=null] : iv_ruleGuardedTransition= ruleGuardedTransition EOF ;
     public final EObject entryRuleGuardedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -16695,8 +16820,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:6737:2: (iv_ruleGuardedTransition= ruleGuardedTransition EOF )
+            // InternalRoom.g:6738:2: iv_ruleGuardedTransition= ruleGuardedTransition EOF
             {
              newCompositeNode(grammarAccess.getGuardedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -16723,7 +16848,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:6745: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 +16874,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:6748: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:6749: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:6749: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:6749: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); 
 
                 	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:6753:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt147=2;
+            int LA147_0 = input.LA(1);
 
-            if ( (LA146_0==RULE_ID) ) {
-                alt146=1;
+            if ( (LA147_0==RULE_ID) ) {
+                alt147=1;
             }
-            switch (alt146) {
+            switch (alt147) {
                 case 1 :
-                    // InternalRoom.g:6716:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6754: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:6754:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6755:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -16800,11 +16925,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6775:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6776: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:6776:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6777:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -16835,11 +16960,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6797:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6798: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:6798:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6799:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -16866,19 +16991,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:6815:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt148=2;
+            int LA148_0 = input.LA(1);
 
-            if ( (LA147_0==34) ) {
-                alt147=1;
+            if ( (LA148_0==34) ) {
+                alt148=1;
             }
-            switch (alt147) {
+            switch (alt148) {
                 case 1 :
-                    // InternalRoom.g:6778:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6816: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:6816:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6817:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -16916,11 +17041,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6841:1: ( (lv_guard_9_0= ruleDetailCode ) )
+            // InternalRoom.g:6842: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:6842:1: (lv_guard_9_0= ruleDetailCode )
+            // InternalRoom.g:6843:3: lv_guard_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); 
@@ -16947,26 +17072,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:6859:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt149=2;
+            int LA149_0 = input.LA(1);
 
-            if ( (LA148_0==94) ) {
-                alt148=1;
+            if ( (LA149_0==94) ) {
+                alt149=1;
             }
-            switch (alt148) {
+            switch (alt149) {
                 case 1 :
-                    // InternalRoom.g:6821:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:6859:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
                     otherlv_10=(Token)match(input,94,FOLLOW_122); 
 
                         	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:6863:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:6864: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:6864:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:6865:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -17024,7 +17149,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleCPBranchTransition"
-    // InternalRoom.g:6855:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
+    // InternalRoom.g:6893:1: entryRuleCPBranchTransition returns [EObject current=null] : iv_ruleCPBranchTransition= ruleCPBranchTransition EOF ;
     public final EObject entryRuleCPBranchTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17032,8 +17157,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:6894:2: (iv_ruleCPBranchTransition= ruleCPBranchTransition EOF )
+            // InternalRoom.g:6895:2: iv_ruleCPBranchTransition= ruleCPBranchTransition EOF
             {
              newCompositeNode(grammarAccess.getCPBranchTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -17060,7 +17185,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:6902: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 +17211,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:6905: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:6906: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:6906: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:6906: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); 
 
                 	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:6910:1: ( (lv_name_1_0= RULE_ID ) )?
+            int alt150=2;
+            int LA150_0 = input.LA(1);
 
-            if ( (LA149_0==RULE_ID) ) {
-                alt149=1;
+            if ( (LA150_0==RULE_ID) ) {
+                alt150=1;
             }
-            switch (alt149) {
+            switch (alt150) {
                 case 1 :
-                    // InternalRoom.g:6873:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6911: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:6911:1: (lv_name_1_0= RULE_ID )
+                    // InternalRoom.g:6912:3: lv_name_1_0= RULE_ID
                     {
                     lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -17137,11 +17262,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6932:1: ( (lv_from_3_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6933: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:6933:1: (lv_from_3_0= ruleTransitionTerminal )
+            // InternalRoom.g:6934:3: lv_from_3_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); 
@@ -17172,11 +17297,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6954:1: ( (lv_to_5_0= ruleTransitionTerminal ) )
+            // InternalRoom.g:6955: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:6955:1: (lv_to_5_0= ruleTransitionTerminal )
+            // InternalRoom.g:6956:3: lv_to_5_0= ruleTransitionTerminal
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); 
@@ -17203,19 +17328,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:6972:2: ( (lv_docu_6_0= ruleDocumentation ) )?
+            int alt151=2;
+            int LA151_0 = input.LA(1);
 
-            if ( (LA150_0==34) ) {
-                alt150=1;
+            if ( (LA151_0==34) ) {
+                alt151=1;
             }
-            switch (alt150) {
+            switch (alt151) {
                 case 1 :
-                    // InternalRoom.g:6935:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6973: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:6973:1: (lv_docu_6_0= ruleDocumentation )
+                    // InternalRoom.g:6974:3: lv_docu_6_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); 
@@ -17253,11 +17378,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:6998:1: ( (lv_condition_9_0= ruleDetailCode ) )
+            // InternalRoom.g:6999: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:6999:1: (lv_condition_9_0= ruleDetailCode )
+            // InternalRoom.g:7000:3: lv_condition_9_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); 
@@ -17284,26 +17409,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:7016:2: (otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) ) )?
+            int alt152=2;
+            int LA152_0 = input.LA(1);
 
-            if ( (LA151_0==94) ) {
-                alt151=1;
+            if ( (LA152_0==94) ) {
+                alt152=1;
             }
-            switch (alt151) {
+            switch (alt152) {
                 case 1 :
-                    // InternalRoom.g:6978:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:7016:4: otherlv_10= 'action' ( (lv_action_11_0= ruleDetailCode ) )
                     {
                     otherlv_10=(Token)match(input,94,FOLLOW_122); 
 
                         	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:7020:1: ( (lv_action_11_0= ruleDetailCode ) )
+                    // InternalRoom.g:7021: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:7021:1: (lv_action_11_0= ruleDetailCode )
+                    // InternalRoom.g:7022:3: lv_action_11_0= ruleDetailCode
                     {
                      
                     	        newCompositeNode(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); 
@@ -17361,7 +17486,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRefinedTransition"
-    // InternalRoom.g:7012:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
+    // InternalRoom.g:7050:1: entryRuleRefinedTransition returns [EObject current=null] : iv_ruleRefinedTransition= ruleRefinedTransition EOF ;
     public final EObject entryRuleRefinedTransition() throws RecognitionException {
         EObject current = null;
 
@@ -17369,8 +17494,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:7051:2: (iv_ruleRefinedTransition= ruleRefinedTransition EOF )
+            // InternalRoom.g:7052:2: iv_ruleRefinedTransition= ruleRefinedTransition EOF
             {
              newCompositeNode(grammarAccess.getRefinedTransitionRule()); 
             pushFollow(FOLLOW_1);
@@ -17397,7 +17522,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:7059: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 +17538,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:7062:28: ( (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' ) )
+            // InternalRoom.g:7063: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:7063:1: (otherlv_0= 'RefinedTransition' ( ( ruleFQN ) ) ( (lv_docu_2_0= ruleDocumentation ) )? otherlv_3= '{' otherlv_4= 'action' ( (lv_action_5_0= ruleDetailCode ) ) otherlv_6= '}' )
+            // InternalRoom.g:7063: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:7067:1: ( ( ruleFQN ) )
+            // InternalRoom.g:7068:1: ( ruleFQN )
             {
-            // InternalRoom.g:7030:1: ( ruleFQN )
-            // InternalRoom.g:7031:3: ruleFQN
+            // InternalRoom.g:7068:1: ( ruleFQN )
+            // InternalRoom.g:7069:3: ruleFQN
             {
 
             			if (current==null) {
@@ -17451,19 +17576,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:7082:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt153=2;
+            int LA153_0 = input.LA(1);
 
-            if ( (LA152_0==34) ) {
-                alt152=1;
+            if ( (LA153_0==34) ) {
+                alt153=1;
             }
-            switch (alt152) {
+            switch (alt153) {
                 case 1 :
-                    // InternalRoom.g:7045:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:7083: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:7083:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:7084:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -17501,11 +17626,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:7108:1: ( (lv_action_5_0= ruleDetailCode ) )
+            // InternalRoom.g:7109: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:7109:1: (lv_action_5_0= ruleDetailCode )
+            // InternalRoom.g:7110:3: lv_action_5_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); 
@@ -17557,7 +17682,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTransitionTerminal"
-    // InternalRoom.g:7100:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
+    // InternalRoom.g:7138:1: entryRuleTransitionTerminal returns [EObject current=null] : iv_ruleTransitionTerminal= ruleTransitionTerminal EOF ;
     public final EObject entryRuleTransitionTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17565,8 +17690,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:7139:2: (iv_ruleTransitionTerminal= ruleTransitionTerminal EOF )
+            // InternalRoom.g:7140:2: iv_ruleTransitionTerminal= ruleTransitionTerminal EOF
             {
              newCompositeNode(grammarAccess.getTransitionTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17593,7 +17718,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:7147: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 +17734,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:7150:28: ( (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal ) )
+            // InternalRoom.g:7151: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:7151:1: (this_StateTerminal_0= ruleStateTerminal | this_TrPointTerminal_1= ruleTrPointTerminal | this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal | this_ChoicepointTerminal_3= ruleChoicepointTerminal )
+            int alt154=4;
             switch ( input.LA(1) ) {
             case RULE_ID:
                 {
-                int LA153_1 = input.LA(2);
+                int LA154_1 = input.LA(2);
 
-                if ( (LA153_1==24) ) {
-                    alt153=3;
+                if ( (LA154_1==24) ) {
+                    alt154=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 ( (LA154_1==EOF||(LA154_1>=14 && LA154_1<=15)||LA154_1==19||LA154_1==34||LA154_1==81||(LA154_1>=86 && LA154_1<=92)||LA154_1==99) ) {
+                    alt154=1;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 153, 1, input);
+                        new NoViableAltException("", 154, 1, input);
 
                     throw nvae;
                 }
@@ -17635,24 +17760,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 100:
                 {
-                alt153=2;
+                alt154=2;
                 }
                 break;
             case 101:
                 {
-                alt153=4;
+                alt154=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 153, 0, input);
+                    new NoViableAltException("", 154, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt153) {
+            switch (alt154) {
                 case 1 :
-                    // InternalRoom.g:7114:5: this_StateTerminal_0= ruleStateTerminal
+                    // InternalRoom.g:7152:5: this_StateTerminal_0= ruleStateTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); 
@@ -17670,7 +17795,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:7124:5: this_TrPointTerminal_1= ruleTrPointTerminal
+                    // InternalRoom.g:7162:5: this_TrPointTerminal_1= ruleTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); 
@@ -17688,7 +17813,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:7134:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
+                    // InternalRoom.g:7172:5: this_SubStateTrPointTerminal_2= ruleSubStateTrPointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); 
@@ -17706,7 +17831,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:7144:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
+                    // InternalRoom.g:7182:5: this_ChoicepointTerminal_3= ruleChoicepointTerminal
                     {
                      
                             newCompositeNode(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); 
@@ -17744,7 +17869,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStateTerminal"
-    // InternalRoom.g:7160:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
+    // InternalRoom.g:7198:1: entryRuleStateTerminal returns [EObject current=null] : iv_ruleStateTerminal= ruleStateTerminal EOF ;
     public final EObject entryRuleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17752,8 +17877,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:7199:2: (iv_ruleStateTerminal= ruleStateTerminal EOF )
+            // InternalRoom.g:7200:2: iv_ruleStateTerminal= ruleStateTerminal EOF
             {
              newCompositeNode(grammarAccess.getStateTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17780,7 +17905,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "ruleStateTerminal"
-    // InternalRoom.g:7169:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
+    // InternalRoom.g:7207:1: ruleStateTerminal returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
     public final EObject ruleStateTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17789,14 +17914,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:7210:28: ( ( (otherlv_0= RULE_ID ) ) )
+            // InternalRoom.g:7211:1: ( (otherlv_0= RULE_ID ) )
             {
-            // InternalRoom.g:7173:1: ( (otherlv_0= RULE_ID ) )
-            // InternalRoom.g:7174:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7211:1: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7212:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7174:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7175:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7212:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7213:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -17831,7 +17956,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrPointTerminal"
-    // InternalRoom.g:7194:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
+    // InternalRoom.g:7232:1: entryRuleTrPointTerminal returns [EObject current=null] : iv_ruleTrPointTerminal= ruleTrPointTerminal EOF ;
     public final EObject entryRuleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17839,8 +17964,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:7233:2: (iv_ruleTrPointTerminal= ruleTrPointTerminal EOF )
+            // InternalRoom.g:7234:2: iv_ruleTrPointTerminal= ruleTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17867,7 +17992,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:7241:1: ruleTrPointTerminal returns [EObject current=null] : (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17877,21 +18002,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:7244:28: ( (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:7245: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:7245:1: (otherlv_0= 'my' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7245: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:7249:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7250:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:7212:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:7213:3: otherlv_1= RULE_ID
+            // InternalRoom.g:7250:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7251:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -17929,7 +18054,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSubStateTrPointTerminal"
-    // InternalRoom.g:7232:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
+    // InternalRoom.g:7270:1: entryRuleSubStateTrPointTerminal returns [EObject current=null] : iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF ;
     public final EObject entryRuleSubStateTrPointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -17937,8 +18062,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:7271:2: (iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF )
+            // InternalRoom.g:7272:2: iv_ruleSubStateTrPointTerminal= ruleSubStateTrPointTerminal EOF
             {
              newCompositeNode(grammarAccess.getSubStateTrPointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -17965,7 +18090,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:7279: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,17 +18101,17 @@ 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:7282:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:7283: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:7283:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= 'of' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7283: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:7283:2: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7284:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7246:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7247:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7284:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7285:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -18007,11 +18132,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:7300:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7301:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7263:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7264:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7301:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7302:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -18049,7 +18174,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleChoicepointTerminal"
-    // InternalRoom.g:7283:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
+    // InternalRoom.g:7321:1: entryRuleChoicepointTerminal returns [EObject current=null] : iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF ;
     public final EObject entryRuleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -18057,8 +18182,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:7322:2: (iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF )
+            // InternalRoom.g:7323:2: iv_ruleChoicepointTerminal= ruleChoicepointTerminal EOF
             {
              newCompositeNode(grammarAccess.getChoicepointTerminalRule()); 
             pushFollow(FOLLOW_1);
@@ -18085,7 +18210,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:7330:1: ruleChoicepointTerminal returns [EObject current=null] : (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) ;
     public final EObject ruleChoicepointTerminal() throws RecognitionException {
         EObject current = null;
 
@@ -18095,21 +18220,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:7333:28: ( (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) ) )
+            // InternalRoom.g:7334: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:7334:1: (otherlv_0= 'cp' ( (otherlv_1= RULE_ID ) ) )
+            // InternalRoom.g:7334: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:7338:1: ( (otherlv_1= RULE_ID ) )
+            // InternalRoom.g:7339:1: (otherlv_1= RULE_ID )
             {
-            // InternalRoom.g:7301:1: (otherlv_1= RULE_ID )
-            // InternalRoom.g:7302:3: otherlv_1= RULE_ID
+            // InternalRoom.g:7339:1: (otherlv_1= RULE_ID )
+            // InternalRoom.g:7340:3: otherlv_1= RULE_ID
             {
 
             			if (current==null) {
@@ -18147,7 +18272,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleTrigger"
-    // InternalRoom.g:7321:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
+    // InternalRoom.g:7359:1: entryRuleTrigger returns [EObject current=null] : iv_ruleTrigger= ruleTrigger EOF ;
     public final EObject entryRuleTrigger() throws RecognitionException {
         EObject current = null;
 
@@ -18155,8 +18280,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:7360:2: (iv_ruleTrigger= ruleTrigger EOF )
+            // InternalRoom.g:7361:2: iv_ruleTrigger= ruleTrigger EOF
             {
              newCompositeNode(grammarAccess.getTriggerRule()); 
             pushFollow(FOLLOW_1);
@@ -18183,7 +18308,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:7368: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,21 +18325,21 @@ 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:7371:28: ( (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' ) )
+            // InternalRoom.g:7372: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:7372:1: (otherlv_0= '<' ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) ) (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )* ( (lv_guard_4_0= ruleGuard ) )? otherlv_5= '>' )
+            // InternalRoom.g:7372: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:7376:1: ( (lv_msgFromIfPairs_1_0= ruleMessageFromIf ) )
+            // InternalRoom.g:7377: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:7377:1: (lv_msgFromIfPairs_1_0= ruleMessageFromIf )
+            // InternalRoom.g:7378:3: lv_msgFromIfPairs_1_0= ruleMessageFromIf
             {
              
             	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); 
@@ -18241,30 +18366,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:7356:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
-            loop154:
+            // InternalRoom.g:7394:2: (otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) ) )*
+            loop155:
             do {
-                int alt154=2;
-                int LA154_0 = input.LA(1);
+                int alt155=2;
+                int LA155_0 = input.LA(1);
 
-                if ( (LA154_0==103) ) {
-                    alt154=1;
+                if ( (LA155_0==103) ) {
+                    alt155=1;
                 }
 
 
-                switch (alt154) {
+                switch (alt155) {
             	case 1 :
-            	    // InternalRoom.g:7356:4: otherlv_2= '|' ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalRoom.g:7394: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:7398:1: ( (lv_msgFromIfPairs_3_0= ruleMessageFromIf ) )
+            	    // InternalRoom.g:7399: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:7399:1: (lv_msgFromIfPairs_3_0= ruleMessageFromIf )
+            	    // InternalRoom.g:7400:3: lv_msgFromIfPairs_3_0= ruleMessageFromIf
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); 
@@ -18296,23 +18421,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop154;
+            	    break loop155;
                 }
             } while (true);
 
-            // InternalRoom.g:7378:4: ( (lv_guard_4_0= ruleGuard ) )?
-            int alt155=2;
-            int LA155_0 = input.LA(1);
+            // InternalRoom.g:7416:4: ( (lv_guard_4_0= ruleGuard ) )?
+            int alt156=2;
+            int LA156_0 = input.LA(1);
 
-            if ( (LA155_0==97) ) {
-                alt155=1;
+            if ( (LA156_0==97) ) {
+                alt156=1;
             }
-            switch (alt155) {
+            switch (alt156) {
                 case 1 :
-                    // InternalRoom.g:7379:1: (lv_guard_4_0= ruleGuard )
+                    // InternalRoom.g:7417: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:7417:1: (lv_guard_4_0= ruleGuard )
+                    // InternalRoom.g:7418:3: lv_guard_4_0= ruleGuard
                     {
                      
                     	        newCompositeNode(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); 
@@ -18367,7 +18492,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleMessageFromIf"
-    // InternalRoom.g:7408:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
+    // InternalRoom.g:7446:1: entryRuleMessageFromIf returns [EObject current=null] : iv_ruleMessageFromIf= ruleMessageFromIf EOF ;
     public final EObject entryRuleMessageFromIf() throws RecognitionException {
         EObject current = null;
 
@@ -18375,8 +18500,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:7447:2: (iv_ruleMessageFromIf= ruleMessageFromIf EOF )
+            // InternalRoom.g:7448:2: iv_ruleMessageFromIf= ruleMessageFromIf EOF
             {
              newCompositeNode(grammarAccess.getMessageFromIfRule()); 
             pushFollow(FOLLOW_1);
@@ -18403,7 +18528,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:7455: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 +18539,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:7458:28: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) ) )
+            // InternalRoom.g:7459: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:7459:1: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= ':' ( (otherlv_2= RULE_ID ) ) )
+            // InternalRoom.g:7459: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:7459:2: ( (otherlv_0= RULE_ID ) )
+            // InternalRoom.g:7460:1: (otherlv_0= RULE_ID )
             {
-            // InternalRoom.g:7422:1: (otherlv_0= RULE_ID )
-            // InternalRoom.g:7423:3: otherlv_0= RULE_ID
+            // InternalRoom.g:7460:1: (otherlv_0= RULE_ID )
+            // InternalRoom.g:7461:3: otherlv_0= RULE_ID
             {
 
             			if (current==null) {
@@ -18445,11 +18570,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:7476:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7477:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7439:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7440:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7477:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7478:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -18487,7 +18612,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleGuard"
-    // InternalRoom.g:7459:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
+    // InternalRoom.g:7497:1: entryRuleGuard returns [EObject current=null] : iv_ruleGuard= ruleGuard EOF ;
     public final EObject entryRuleGuard() throws RecognitionException {
         EObject current = null;
 
@@ -18495,8 +18620,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:7498:2: (iv_ruleGuard= ruleGuard EOF )
+            // InternalRoom.g:7499:2: iv_ruleGuard= ruleGuard EOF
             {
              newCompositeNode(grammarAccess.getGuardRule()); 
             pushFollow(FOLLOW_1);
@@ -18523,7 +18648,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:7506: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 +18659,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:7509:28: ( (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) ) )
+            // InternalRoom.g:7510: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:7510:1: (otherlv_0= 'guard' ( (lv_guard_1_0= ruleDetailCode ) ) )
+            // InternalRoom.g:7510: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:7514:1: ( (lv_guard_1_0= ruleDetailCode ) )
+            // InternalRoom.g:7515: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:7515:1: (lv_guard_1_0= ruleDetailCode )
+            // InternalRoom.g:7516:3: lv_guard_1_0= ruleDetailCode
             {
              
             	        newCompositeNode(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); 
@@ -18596,7 +18721,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleProtocolSemantics"
-    // InternalRoom.g:7502:1: entryRuleProtocolSemantics returns [EObject current=null] : iv_ruleProtocolSemantics= ruleProtocolSemantics EOF ;
+    // InternalRoom.g:7540:1: entryRuleProtocolSemantics returns [EObject current=null] : iv_ruleProtocolSemantics= ruleProtocolSemantics EOF ;
     public final EObject entryRuleProtocolSemantics() throws RecognitionException {
         EObject current = null;
 
@@ -18604,8 +18729,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:7541:2: (iv_ruleProtocolSemantics= ruleProtocolSemantics EOF )
+            // InternalRoom.g:7542:2: iv_ruleProtocolSemantics= ruleProtocolSemantics EOF
             {
              newCompositeNode(grammarAccess.getProtocolSemanticsRule()); 
             pushFollow(FOLLOW_1);
@@ -18632,7 +18757,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:7549: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 +18770,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:7552:28: ( ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' ) )
+            // InternalRoom.g:7553: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:7553:1: ( () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}' )
+            // InternalRoom.g:7553:2: () otherlv_1= 'semantics' otherlv_2= '{' ( (lv_rules_3_0= ruleSemanticsRule ) )* otherlv_4= '}'
             {
-            // InternalRoom.g:7515:2: ()
-            // InternalRoom.g:7516:5: 
+            // InternalRoom.g:7553:2: ()
+            // InternalRoom.g:7554:5: 
             {
 
                     current = forceCreateModelElement(
@@ -18670,23 +18795,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_2, grammarAccess.getProtocolSemanticsAccess().getLeftCurlyBracketKeyword_2());
                 
-            // InternalRoom.g:7529:1: ( (lv_rules_3_0= ruleSemanticsRule ) )*
-            loop156:
+            // InternalRoom.g:7567:1: ( (lv_rules_3_0= ruleSemanticsRule ) )*
+            loop157:
             do {
-                int alt156=2;
-                int LA156_0 = input.LA(1);
+                int alt157=2;
+                int LA157_0 = input.LA(1);
 
-                if ( ((LA156_0>=106 && LA156_0<=107)) ) {
-                    alt156=1;
+                if ( ((LA157_0>=106 && LA157_0<=107)) ) {
+                    alt157=1;
                 }
 
 
-                switch (alt156) {
+                switch (alt157) {
             	case 1 :
-            	    // InternalRoom.g:7530:1: (lv_rules_3_0= ruleSemanticsRule )
+            	    // InternalRoom.g:7568: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:7568:1: (lv_rules_3_0= ruleSemanticsRule )
+            	    // InternalRoom.g:7569:3: lv_rules_3_0= ruleSemanticsRule
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); 
@@ -18715,7 +18840,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop156;
+            	    break loop157;
                 }
             } while (true);
 
@@ -18744,7 +18869,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSemanticsRule"
-    // InternalRoom.g:7559:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
+    // InternalRoom.g:7597:1: entryRuleSemanticsRule returns [EObject current=null] : iv_ruleSemanticsRule= ruleSemanticsRule EOF ;
     public final EObject entryRuleSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18752,8 +18877,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:7598:2: (iv_ruleSemanticsRule= ruleSemanticsRule EOF )
+            // InternalRoom.g:7599:2: iv_ruleSemanticsRule= ruleSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -18780,7 +18905,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:7606: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 +18917,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:7609:28: ( (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule ) )
+            // InternalRoom.g:7610: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:7610:1: (this_InSemanticsRule_0= ruleInSemanticsRule | this_OutSemanticsRule_1= ruleOutSemanticsRule )
+            int alt158=2;
+            int LA158_0 = input.LA(1);
 
-            if ( (LA157_0==106) ) {
-                alt157=1;
+            if ( (LA158_0==106) ) {
+                alt158=1;
             }
-            else if ( (LA157_0==107) ) {
-                alt157=2;
+            else if ( (LA158_0==107) ) {
+                alt158=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 157, 0, input);
+                    new NoViableAltException("", 158, 0, input);
 
                 throw nvae;
             }
-            switch (alt157) {
+            switch (alt158) {
                 case 1 :
-                    // InternalRoom.g:7573:5: this_InSemanticsRule_0= ruleInSemanticsRule
+                    // InternalRoom.g:7611:5: this_InSemanticsRule_0= ruleInSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); 
@@ -18831,7 +18956,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:7583:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
+                    // InternalRoom.g:7621:5: this_OutSemanticsRule_1= ruleOutSemanticsRule
                     {
                      
                             newCompositeNode(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); 
@@ -18869,7 +18994,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInSemanticsRule"
-    // InternalRoom.g:7599:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
+    // InternalRoom.g:7637:1: entryRuleInSemanticsRule returns [EObject current=null] : iv_ruleInSemanticsRule= ruleInSemanticsRule EOF ;
     public final EObject entryRuleInSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -18877,8 +19002,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:7638:2: (iv_ruleInSemanticsRule= ruleInSemanticsRule EOF )
+            // InternalRoom.g:7639:2: iv_ruleInSemanticsRule= ruleInSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getInSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -18905,7 +19030,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:7646: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 +19051,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:7649: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:7650: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:7650: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:7650: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,11 +19065,11 @@ 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:7658:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7659:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7621:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7622:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7659:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7660:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -18961,46 +19086,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:7671: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 alt161=2;
+            int LA161_0 = input.LA(1);
 
-            if ( (LA160_0==19) ) {
-                alt160=1;
+            if ( (LA161_0==19) ) {
+                alt161=1;
             }
-            switch (alt160) {
+            switch (alt161) {
                 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:7671: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); 
 
                         	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:7675:1: ( ( (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);
 
-                    if ( ((LA159_0>=106 && LA159_0<=107)) ) {
-                        alt159=1;
+                    if ( ((LA160_0>=106 && LA160_0<=107)) ) {
+                        alt160=1;
                     }
-                    else if ( (LA159_0==20) ) {
-                        alt159=2;
+                    else if ( (LA160_0==20) ) {
+                        alt160=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 159, 0, input);
+                            new NoViableAltException("", 160, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt159) {
+                    switch (alt160) {
                         case 1 :
-                            // InternalRoom.g:7637:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7675: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:7675:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7676: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:7676:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7677:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -19031,20 +19156,20 @@ 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:7694: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:7694:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7694: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); 
 
                                 	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:7698:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7699: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:7699:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7700:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
@@ -19071,31 +19196,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalRoom.g:7678:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt158=0;
-                            loop158:
+                            // InternalRoom.g:7716:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt159=0;
+                            loop159:
                             do {
-                                int alt158=2;
-                                int LA158_0 = input.LA(1);
+                                int alt159=2;
+                                int LA159_0 = input.LA(1);
 
-                                if ( (LA158_0==25) ) {
-                                    alt158=1;
+                                if ( (LA159_0==25) ) {
+                                    alt159=1;
                                 }
 
 
-                                switch (alt158) {
+                                switch (alt159) {
                             	case 1 :
-                            	    // InternalRoom.g:7678:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7716:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
                             	    otherlv_7=(Token)match(input,25,FOLLOW_135); 
 
                             	        	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:7720:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7721: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:7721:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7722:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -19127,12 +19252,12 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt158 >= 1 ) break loop158;
+                            	    if ( cnt159 >= 1 ) break loop159;
                                         EarlyExitException eee =
-                                            new EarlyExitException(158, input);
+                                            new EarlyExitException(159, input);
                                         throw eee;
                                 }
-                                cnt158++;
+                                cnt159++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,21,FOLLOW_2); 
@@ -19175,7 +19300,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleOutSemanticsRule"
-    // InternalRoom.g:7712:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
+    // InternalRoom.g:7750:1: entryRuleOutSemanticsRule returns [EObject current=null] : iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF ;
     public final EObject entryRuleOutSemanticsRule() throws RecognitionException {
         EObject current = null;
 
@@ -19183,8 +19308,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:7751:2: (iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF )
+            // InternalRoom.g:7752:2: iv_ruleOutSemanticsRule= ruleOutSemanticsRule EOF
             {
              newCompositeNode(grammarAccess.getOutSemanticsRuleRule()); 
             pushFollow(FOLLOW_1);
@@ -19211,7 +19336,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:7759: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 +19357,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:7762: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:7763: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:7763: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:7763: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,11 +19371,11 @@ 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:7771:1: ( (otherlv_2= RULE_ID ) )
+            // InternalRoom.g:7772:1: (otherlv_2= RULE_ID )
             {
-            // InternalRoom.g:7734:1: (otherlv_2= RULE_ID )
-            // InternalRoom.g:7735:3: otherlv_2= RULE_ID
+            // InternalRoom.g:7772:1: (otherlv_2= RULE_ID )
+            // InternalRoom.g:7773:3: otherlv_2= RULE_ID
             {
 
             			if (current==null) {
@@ -19267,46 +19392,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:7784: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 alt164=2;
+            int LA164_0 = input.LA(1);
 
-            if ( (LA163_0==19) ) {
-                alt163=1;
+            if ( (LA164_0==19) ) {
+                alt164=1;
             }
-            switch (alt163) {
+            switch (alt164) {
                 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:7784: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); 
 
                         	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:7788:1: ( ( (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 ( ((LA162_0>=106 && LA162_0<=107)) ) {
-                        alt162=1;
+                    if ( ((LA163_0>=106 && LA163_0<=107)) ) {
+                        alt163=1;
                     }
-                    else if ( (LA162_0==20) ) {
-                        alt162=2;
+                    else if ( (LA163_0==20) ) {
+                        alt163=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 162, 0, input);
+                            new NoViableAltException("", 163, 0, input);
 
                         throw nvae;
                     }
-                    switch (alt162) {
+                    switch (alt163) {
                         case 1 :
-                            // InternalRoom.g:7750:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7788: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:7788:2: ( (lv_followUps_4_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7789: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:7789:1: (lv_followUps_4_0= ruleSemanticsRule )
+                            // InternalRoom.g:7790:3: lv_followUps_4_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); 
@@ -19337,20 +19462,20 @@ 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:7807: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:7807:6: (otherlv_5= '(' ( (lv_followUps_6_0= ruleSemanticsRule ) ) (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+ otherlv_9= ')' )
+                            // InternalRoom.g:7807: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); 
 
                                 	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:7811:1: ( (lv_followUps_6_0= ruleSemanticsRule ) )
+                            // InternalRoom.g:7812: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:7812:1: (lv_followUps_6_0= ruleSemanticsRule )
+                            // InternalRoom.g:7813:3: lv_followUps_6_0= ruleSemanticsRule
                             {
                              
                             	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); 
@@ -19377,31 +19502,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                             }
 
-                            // InternalRoom.g:7791:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
-                            int cnt161=0;
-                            loop161:
+                            // InternalRoom.g:7829:2: (otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) ) )+
+                            int cnt162=0;
+                            loop162:
                             do {
-                                int alt161=2;
-                                int LA161_0 = input.LA(1);
+                                int alt162=2;
+                                int LA162_0 = input.LA(1);
 
-                                if ( (LA161_0==25) ) {
-                                    alt161=1;
+                                if ( (LA162_0==25) ) {
+                                    alt162=1;
                                 }
 
 
-                                switch (alt161) {
+                                switch (alt162) {
                             	case 1 :
-                            	    // InternalRoom.g:7791:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7829:4: otherlv_7= ',' ( (lv_followUps_8_0= ruleSemanticsRule ) )
                             	    {
                             	    otherlv_7=(Token)match(input,25,FOLLOW_135); 
 
                             	        	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:7833:1: ( (lv_followUps_8_0= ruleSemanticsRule ) )
+                            	    // InternalRoom.g:7834: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:7834:1: (lv_followUps_8_0= ruleSemanticsRule )
+                            	    // InternalRoom.g:7835:3: lv_followUps_8_0= ruleSemanticsRule
                             	    {
                             	     
                             	    	        newCompositeNode(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); 
@@ -19433,12 +19558,12 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             	    break;
 
                             	default :
-                            	    if ( cnt161 >= 1 ) break loop161;
+                            	    if ( cnt162 >= 1 ) break loop162;
                                         EarlyExitException eee =
-                                            new EarlyExitException(161, input);
+                                            new EarlyExitException(162, input);
                                         throw eee;
                                 }
-                                cnt161++;
+                                cnt162++;
                             } while (true);
 
                             otherlv_9=(Token)match(input,21,FOLLOW_2); 
@@ -19481,7 +19606,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotation"
-    // InternalRoom.g:7825:1: entryRuleAnnotation returns [EObject current=null] : iv_ruleAnnotation= ruleAnnotation EOF ;
+    // InternalRoom.g:7863:1: entryRuleAnnotation returns [EObject current=null] : iv_ruleAnnotation= ruleAnnotation EOF ;
     public final EObject entryRuleAnnotation() throws RecognitionException {
         EObject current = null;
 
@@ -19489,8 +19614,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:7864:2: (iv_ruleAnnotation= ruleAnnotation EOF )
+            // InternalRoom.g:7865:2: iv_ruleAnnotation= ruleAnnotation EOF
             {
              newCompositeNode(grammarAccess.getAnnotationRule()); 
             pushFollow(FOLLOW_1);
@@ -19517,7 +19642,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:7872: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 +19658,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:7875:28: ( (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? ) )
+            // InternalRoom.g:7876: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:7876:1: (otherlv_0= '@' ( ( ruleFQN ) ) (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )? )
+            // InternalRoom.g:7876: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:7880:1: ( ( ruleFQN ) )
+            // InternalRoom.g:7881:1: ( ruleFQN )
             {
-            // InternalRoom.g:7843:1: ( ruleFQN )
-            // InternalRoom.g:7844:3: ruleFQN
+            // InternalRoom.g:7881:1: ( ruleFQN )
+            // InternalRoom.g:7882:3: ruleFQN
             {
 
             			if (current==null) {
@@ -19571,26 +19696,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:7895:2: (otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')' )?
+            int alt166=2;
+            int LA166_0 = input.LA(1);
 
-            if ( (LA165_0==20) ) {
-                alt165=1;
+            if ( (LA166_0==20) ) {
+                alt166=1;
             }
-            switch (alt165) {
+            switch (alt166) {
                 case 1 :
-                    // InternalRoom.g:7857:4: otherlv_2= '(' ( (lv_attributes_3_0= ruleKeyValue ) ) (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )* otherlv_6= ')'
+                    // InternalRoom.g:7895: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:7899:1: ( (lv_attributes_3_0= ruleKeyValue ) )
+                    // InternalRoom.g:7900: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:7900:1: (lv_attributes_3_0= ruleKeyValue )
+                    // InternalRoom.g:7901:3: lv_attributes_3_0= ruleKeyValue
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); 
@@ -19617,30 +19742,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:7879:2: (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )*
-                    loop164:
+                    // InternalRoom.g:7917:2: (otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) ) )*
+                    loop165:
                     do {
-                        int alt164=2;
-                        int LA164_0 = input.LA(1);
+                        int alt165=2;
+                        int LA165_0 = input.LA(1);
 
-                        if ( (LA164_0==25) ) {
-                            alt164=1;
+                        if ( (LA165_0==25) ) {
+                            alt165=1;
                         }
 
 
-                        switch (alt164) {
+                        switch (alt165) {
                     	case 1 :
-                    	    // InternalRoom.g:7879:4: otherlv_4= ',' ( (lv_attributes_5_0= ruleKeyValue ) )
+                    	    // InternalRoom.g:7917: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:7921:1: ( (lv_attributes_5_0= ruleKeyValue ) )
+                    	    // InternalRoom.g:7922: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:7922:1: (lv_attributes_5_0= ruleKeyValue )
+                    	    // InternalRoom.g:7923:3: lv_attributes_5_0= ruleKeyValue
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); 
@@ -19672,7 +19797,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop164;
+                    	    break loop165;
                         }
                     } while (true);
 
@@ -19707,7 +19832,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleKeyValue"
-    // InternalRoom.g:7913:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
+    // InternalRoom.g:7951:1: entryRuleKeyValue returns [EObject current=null] : iv_ruleKeyValue= ruleKeyValue EOF ;
     public final EObject entryRuleKeyValue() throws RecognitionException {
         EObject current = null;
 
@@ -19715,8 +19840,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:7952:2: (iv_ruleKeyValue= ruleKeyValue EOF )
+            // InternalRoom.g:7953:2: iv_ruleKeyValue= ruleKeyValue EOF
             {
              newCompositeNode(grammarAccess.getKeyValueRule()); 
             pushFollow(FOLLOW_1);
@@ -19743,7 +19868,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:7960: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,17 +19880,17 @@ 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:7963:28: ( ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) ) )
+            // InternalRoom.g:7964: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:7964:1: ( ( (lv_key_0_0= RULE_ID ) ) otherlv_1= '=' ( (lv_value_2_0= ruleLiteral ) ) )
+            // InternalRoom.g:7964: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:7964:2: ( (lv_key_0_0= RULE_ID ) )
+            // InternalRoom.g:7965: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:7965:1: (lv_key_0_0= RULE_ID )
+            // InternalRoom.g:7966:3: lv_key_0_0= RULE_ID
             {
             lv_key_0_0=(Token)match(input,RULE_ID,FOLLOW_138); 
 
@@ -19791,11 +19916,11 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:7986:1: ( (lv_value_2_0= ruleLiteral ) )
+            // InternalRoom.g:7987: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:7987:1: (lv_value_2_0= ruleLiteral )
+            // InternalRoom.g:7988:3: lv_value_2_0= ruleLiteral
             {
              
             	        newCompositeNode(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); 
@@ -19843,7 +19968,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationType"
-    // InternalRoom.g:7974:1: entryRuleAnnotationType returns [EObject current=null] : iv_ruleAnnotationType= ruleAnnotationType EOF ;
+    // InternalRoom.g:8012:1: entryRuleAnnotationType returns [EObject current=null] : iv_ruleAnnotationType= ruleAnnotationType EOF ;
     public final EObject entryRuleAnnotationType() throws RecognitionException {
         EObject current = null;
 
@@ -19851,8 +19976,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:8013:2: (iv_ruleAnnotationType= ruleAnnotationType EOF )
+            // InternalRoom.g:8014:2: iv_ruleAnnotationType= ruleAnnotationType EOF
             {
              newCompositeNode(grammarAccess.getAnnotationTypeRule()); 
             pushFollow(FOLLOW_1);
@@ -19879,7 +20004,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:8021: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 +20031,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:8024: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:8025: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:8025: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:8025: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:8029:1: ( (lv_name_1_0= RULE_ID ) )
+            // InternalRoom.g:8030: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:8030:1: (lv_name_1_0= RULE_ID )
+            // InternalRoom.g:8031:3: lv_name_1_0= RULE_ID
             {
             lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_4); 
 
@@ -19942,19 +20067,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:8047:2: ( (lv_docu_2_0= ruleDocumentation ) )?
+            int alt167=2;
+            int LA167_0 = input.LA(1);
 
-            if ( (LA166_0==34) ) {
-                alt166=1;
+            if ( (LA167_0==34) ) {
+                alt167=1;
             }
-            switch (alt166) {
+            switch (alt167) {
                 case 1 :
-                    // InternalRoom.g:8010:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:8048: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:8048:1: (lv_docu_2_0= ruleDocumentation )
+                    // InternalRoom.g:8049:3: lv_docu_2_0= ruleDocumentation
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); 
@@ -19996,31 +20121,31 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	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:8077:1: ( ( (lv_targets_6_0= ruleAnnotationTargetType ) ) | (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' ) )
+            int alt169=2;
+            int LA169_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 ( (LA169_0==28||LA169_0==42||LA169_0==48||LA169_0==51||LA169_0==55||LA169_0==59||LA169_0==64||LA169_0==66||LA169_0==79) ) {
+                alt169=1;
             }
-            else if ( (LA168_0==14) ) {
-                alt168=2;
+            else if ( (LA169_0==14) ) {
+                alt169=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 168, 0, input);
+                    new NoViableAltException("", 169, 0, input);
 
                 throw nvae;
             }
-            switch (alt168) {
+            switch (alt169) {
                 case 1 :
-                    // InternalRoom.g:8039:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8077: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:8077:2: ( (lv_targets_6_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8078: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:8078:1: (lv_targets_6_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8079:3: lv_targets_6_0= ruleAnnotationTargetType
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); 
@@ -20051,20 +20176,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:8096: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:8096:6: (otherlv_7= '{' ( (lv_targets_8_0= ruleAnnotationTargetType ) ) (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )* otherlv_11= '}' )
+                    // InternalRoom.g:8096: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); 
 
                         	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:8100:1: ( (lv_targets_8_0= ruleAnnotationTargetType ) )
+                    // InternalRoom.g:8101: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:8101:1: (lv_targets_8_0= ruleAnnotationTargetType )
+                    // InternalRoom.g:8102:3: lv_targets_8_0= ruleAnnotationTargetType
                     {
                      
                     	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); 
@@ -20091,30 +20216,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                     }
 
-                    // InternalRoom.g:8080:2: (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )*
-                    loop167:
+                    // InternalRoom.g:8118:2: (otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) ) )*
+                    loop168:
                     do {
-                        int alt167=2;
-                        int LA167_0 = input.LA(1);
+                        int alt168=2;
+                        int LA168_0 = input.LA(1);
 
-                        if ( (LA167_0==25) ) {
-                            alt167=1;
+                        if ( (LA168_0==25) ) {
+                            alt168=1;
                         }
 
 
-                        switch (alt167) {
+                        switch (alt168) {
                     	case 1 :
-                    	    // InternalRoom.g:8080:4: otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) )
+                    	    // InternalRoom.g:8118:4: otherlv_9= ',' ( (lv_targets_10_0= ruleAnnotationTargetType ) )
                     	    {
                     	    otherlv_9=(Token)match(input,25,FOLLOW_143); 
 
                     	        	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:8122:1: ( (lv_targets_10_0= ruleAnnotationTargetType ) )
+                    	    // InternalRoom.g:8123: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:8123:1: (lv_targets_10_0= ruleAnnotationTargetType )
+                    	    // InternalRoom.g:8124:3: lv_targets_10_0= ruleAnnotationTargetType
                     	    {
                     	     
                     	    	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); 
@@ -20146,7 +20271,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     	    break;
 
                     	default :
-                    	    break loop167;
+                    	    break loop168;
                         }
                     } while (true);
 
@@ -20163,23 +20288,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8106:3: ( (lv_attributes_12_0= ruleAnnotationAttribute ) )*
-            loop169:
+            // InternalRoom.g:8144:3: ( (lv_attributes_12_0= ruleAnnotationAttribute ) )*
+            loop170:
             do {
-                int alt169=2;
-                int LA169_0 = input.LA(1);
+                int alt170=2;
+                int LA170_0 = input.LA(1);
 
-                if ( ((LA169_0>=111 && LA169_0<=112)) ) {
-                    alt169=1;
+                if ( ((LA170_0>=111 && LA170_0<=112)) ) {
+                    alt170=1;
                 }
 
 
-                switch (alt169) {
+                switch (alt170) {
             	case 1 :
-            	    // InternalRoom.g:8107:1: (lv_attributes_12_0= ruleAnnotationAttribute )
+            	    // InternalRoom.g:8145: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:8145:1: (lv_attributes_12_0= ruleAnnotationAttribute )
+            	    // InternalRoom.g:8146:3: lv_attributes_12_0= ruleAnnotationAttribute
             	    {
             	     
             	    	        newCompositeNode(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); 
@@ -20208,7 +20333,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop169;
+            	    break loop170;
                 }
             } while (true);
 
@@ -20237,7 +20362,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleAnnotationAttribute"
-    // InternalRoom.g:8136:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
+    // InternalRoom.g:8174:1: entryRuleAnnotationAttribute returns [EObject current=null] : iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF ;
     public final EObject entryRuleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20245,8 +20370,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:8175:2: (iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF )
+            // InternalRoom.g:8176:2: iv_ruleAnnotationAttribute= ruleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20273,7 +20398,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:8183: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 +20410,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:8186:28: ( (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute ) )
+            // InternalRoom.g:8187: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:8187:1: (this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute | this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute )
+            int alt171=2;
+            int LA171_0 = input.LA(1);
 
-            if ( (LA170_0==111) ) {
-                int LA170_1 = input.LA(2);
+            if ( (LA171_0==111) ) {
+                int LA171_1 = input.LA(2);
 
-                if ( (LA170_1==113) ) {
-                    int LA170_3 = input.LA(3);
+                if ( (LA171_1==113) ) {
+                    int LA171_3 = input.LA(3);
 
-                    if ( (LA170_3==RULE_ID) ) {
-                        int LA170_4 = input.LA(4);
+                    if ( (LA171_3==RULE_ID) ) {
+                        int LA171_4 = input.LA(4);
 
-                        if ( (LA170_4==16) ) {
-                            int LA170_5 = input.LA(5);
+                        if ( (LA171_4==16) ) {
+                            int LA171_5 = input.LA(5);
 
-                            if ( (LA170_5==14) ) {
-                                alt170=2;
+                            if ( (LA171_5==14) ) {
+                                alt171=2;
                             }
-                            else if ( ((LA170_5>=129 && LA170_5<=132)) ) {
-                                alt170=1;
+                            else if ( ((LA171_5>=129 && LA171_5<=132)) ) {
+                                alt171=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 170, 5, input);
+                                    new NoViableAltException("", 171, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 170, 4, input);
+                                new NoViableAltException("", 171, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 170, 3, input);
+                            new NoViableAltException("", 171, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 170, 1, input);
+                        new NoViableAltException("", 171, 1, input);
 
                     throw nvae;
                 }
             }
-            else if ( (LA170_0==112) ) {
-                int LA170_2 = input.LA(2);
+            else if ( (LA171_0==112) ) {
+                int LA171_2 = input.LA(2);
 
-                if ( (LA170_2==113) ) {
-                    int LA170_3 = input.LA(3);
+                if ( (LA171_2==113) ) {
+                    int LA171_3 = input.LA(3);
 
-                    if ( (LA170_3==RULE_ID) ) {
-                        int LA170_4 = input.LA(4);
+                    if ( (LA171_3==RULE_ID) ) {
+                        int LA171_4 = input.LA(4);
 
-                        if ( (LA170_4==16) ) {
-                            int LA170_5 = input.LA(5);
+                        if ( (LA171_4==16) ) {
+                            int LA171_5 = input.LA(5);
 
-                            if ( (LA170_5==14) ) {
-                                alt170=2;
+                            if ( (LA171_5==14) ) {
+                                alt171=2;
                             }
-                            else if ( ((LA170_5>=129 && LA170_5<=132)) ) {
-                                alt170=1;
+                            else if ( ((LA171_5>=129 && LA171_5<=132)) ) {
+                                alt171=1;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 170, 5, input);
+                                    new NoViableAltException("", 171, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 170, 4, input);
+                                new NoViableAltException("", 171, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 170, 3, input);
+                            new NoViableAltException("", 171, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 170, 2, input);
+                        new NoViableAltException("", 171, 2, input);
 
                     throw nvae;
                 }
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 170, 0, input);
+                    new NoViableAltException("", 171, 0, input);
 
                 throw nvae;
             }
-            switch (alt170) {
+            switch (alt171) {
                 case 1 :
-                    // InternalRoom.g:8150:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
+                    // InternalRoom.g:8188:5: this_SimpleAnnotationAttribute_0= ruleSimpleAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); 
@@ -20410,7 +20535,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8160:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
+                    // InternalRoom.g:8198:5: this_EnumAnnotationAttribute_1= ruleEnumAnnotationAttribute
                     {
                      
                             newCompositeNode(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); 
@@ -20448,7 +20573,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleSimpleAnnotationAttribute"
-    // InternalRoom.g:8176:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
+    // InternalRoom.g:8214:1: entryRuleSimpleAnnotationAttribute returns [EObject current=null] : iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF ;
     public final EObject entryRuleSimpleAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20456,8 +20581,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:8215:2: (iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF )
+            // InternalRoom.g:8216:2: iv_ruleSimpleAnnotationAttribute= ruleSimpleAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getSimpleAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20484,7 +20609,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:8223: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,37 +20624,37 @@ 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:8226: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:8227: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:8227: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:8227: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:8227:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt172=2;
+            int LA172_0 = input.LA(1);
 
-            if ( (LA171_0==111) ) {
-                alt171=1;
+            if ( (LA172_0==111) ) {
+                alt172=1;
             }
-            else if ( (LA171_0==112) ) {
-                alt171=2;
+            else if ( (LA172_0==112) ) {
+                alt172=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 171, 0, input);
+                    new NoViableAltException("", 172, 0, input);
 
                 throw nvae;
             }
-            switch (alt171) {
+            switch (alt172) {
                 case 1 :
-                    // InternalRoom.g:8189:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8227: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:8227:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8228: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:8228:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8229:3: lv_optional_0_0= 'optional'
                     {
                     lv_optional_0_0=(Token)match(input,111,FOLLOW_144); 
 
@@ -20551,7 +20676,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8205:7: otherlv_1= 'mandatory'
+                    // InternalRoom.g:8243:7: otherlv_1= 'mandatory'
                     {
                     otherlv_1=(Token)match(input,112,FOLLOW_144); 
 
@@ -20567,11 +20692,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:8251:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalRoom.g:8252: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:8252:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8253:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -20597,11 +20722,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:8273:1: ( (lv_type_5_0= ruleLiteralType ) )
+            // InternalRoom.g:8274: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:8274:1: (lv_type_5_0= ruleLiteralType )
+            // InternalRoom.g:8275:3: lv_type_5_0= ruleLiteralType
             {
              
             	        newCompositeNode(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); 
@@ -20649,7 +20774,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleEnumAnnotationAttribute"
-    // InternalRoom.g:8261:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
+    // InternalRoom.g:8299:1: entryRuleEnumAnnotationAttribute returns [EObject current=null] : iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF ;
     public final EObject entryRuleEnumAnnotationAttribute() throws RecognitionException {
         EObject current = null;
 
@@ -20657,8 +20782,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:8300:2: (iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF )
+            // InternalRoom.g:8301:2: iv_ruleEnumAnnotationAttribute= ruleEnumAnnotationAttribute EOF
             {
              newCompositeNode(grammarAccess.getEnumAnnotationAttributeRule()); 
             pushFollow(FOLLOW_1);
@@ -20685,7 +20810,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:8308: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,37 +20828,37 @@ 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:8311: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:8312: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:8312: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:8312: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:8312:2: ( ( (lv_optional_0_0= 'optional' ) ) | otherlv_1= 'mandatory' )
+            int alt173=2;
+            int LA173_0 = input.LA(1);
 
-            if ( (LA172_0==111) ) {
-                alt172=1;
+            if ( (LA173_0==111) ) {
+                alt173=1;
             }
-            else if ( (LA172_0==112) ) {
-                alt172=2;
+            else if ( (LA173_0==112) ) {
+                alt173=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 172, 0, input);
+                    new NoViableAltException("", 173, 0, input);
 
                 throw nvae;
             }
-            switch (alt172) {
+            switch (alt173) {
                 case 1 :
-                    // InternalRoom.g:8274:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8312: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:8312:3: ( (lv_optional_0_0= 'optional' ) )
+                    // InternalRoom.g:8313: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:8313:1: (lv_optional_0_0= 'optional' )
+                    // InternalRoom.g:8314:3: lv_optional_0_0= 'optional'
                     {
                     lv_optional_0_0=(Token)match(input,111,FOLLOW_144); 
 
@@ -20755,7 +20880,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8290:7: otherlv_1= 'mandatory'
+                    // InternalRoom.g:8328:7: otherlv_1= 'mandatory'
                     {
                     otherlv_1=(Token)match(input,112,FOLLOW_144); 
 
@@ -20771,11 +20896,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:8336:1: ( (lv_name_3_0= RULE_ID ) )
+            // InternalRoom.g:8337: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:8337:1: (lv_name_3_0= RULE_ID )
+            // InternalRoom.g:8338:3: lv_name_3_0= RULE_ID
             {
             lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_8); 
 
@@ -20805,11 +20930,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:8362:1: ( (lv_values_6_0= RULE_STRING ) )
+            // InternalRoom.g:8363: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:8363:1: (lv_values_6_0= RULE_STRING )
+            // InternalRoom.g:8364:3: lv_values_6_0= RULE_STRING
             {
             lv_values_6_0=(Token)match(input,RULE_STRING,FOLLOW_20); 
 
@@ -20831,30 +20956,30 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:8342:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
-            loop173:
+            // InternalRoom.g:8380:2: (otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) ) )*
+            loop174:
             do {
-                int alt173=2;
-                int LA173_0 = input.LA(1);
+                int alt174=2;
+                int LA174_0 = input.LA(1);
 
-                if ( (LA173_0==25) ) {
-                    alt173=1;
+                if ( (LA174_0==25) ) {
+                    alt174=1;
                 }
 
 
-                switch (alt173) {
+                switch (alt174) {
             	case 1 :
-            	    // InternalRoom.g:8342:4: otherlv_7= ',' ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalRoom.g:8380: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:8384:1: ( (lv_values_8_0= RULE_STRING ) )
+            	    // InternalRoom.g:8385: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:8385:1: (lv_values_8_0= RULE_STRING )
+            	    // InternalRoom.g:8386:3: lv_values_8_0= RULE_STRING
             	    {
             	    lv_values_8_0=(Token)match(input,RULE_STRING,FOLLOW_20); 
 
@@ -20881,7 +21006,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop173;
+            	    break loop174;
                 }
             } while (true);
 
@@ -20910,7 +21035,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleImport"
-    // InternalRoom.g:8376:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ;
+    // InternalRoom.g:8414:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ;
     public final EObject entryRuleImport() throws RecognitionException {
         EObject current = null;
 
@@ -20918,8 +21043,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:8415:2: (iv_ruleImport= ruleImport EOF )
+            // InternalRoom.g:8416:2: iv_ruleImport= ruleImport EOF
             {
              newCompositeNode(grammarAccess.getImportRule()); 
             pushFollow(FOLLOW_1);
@@ -20946,7 +21071,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:8423: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,44 +21085,44 @@ 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:8426:28: ( (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) ) )
+            // InternalRoom.g:8427: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:8427:1: (otherlv_0= 'import' ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' ) ( (lv_importURI_4_0= RULE_STRING ) ) )
+            // InternalRoom.g:8427: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); 
 
                 	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:8431:1: ( ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' ) | otherlv_3= 'model' )
+            int alt175=2;
+            int LA175_0 = input.LA(1);
 
-            if ( (LA174_0==RULE_ID) ) {
-                alt174=1;
+            if ( (LA175_0==RULE_ID) ) {
+                alt175=1;
             }
-            else if ( (LA174_0==116) ) {
-                alt174=2;
+            else if ( (LA175_0==116) ) {
+                alt175=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 174, 0, input);
+                    new NoViableAltException("", 175, 0, input);
 
                 throw nvae;
             }
-            switch (alt174) {
+            switch (alt175) {
                 case 1 :
-                    // InternalRoom.g:8393:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
+                    // InternalRoom.g:8431: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:8431:2: ( ( (lv_importedNamespace_1_0= ruleImportedFQN ) ) otherlv_2= 'from' )
+                    // InternalRoom.g:8431: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:8431:3: ( (lv_importedNamespace_1_0= ruleImportedFQN ) )
+                    // InternalRoom.g:8432: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:8432:1: (lv_importedNamespace_1_0= ruleImportedFQN )
+                    // InternalRoom.g:8433:3: lv_importedNamespace_1_0= ruleImportedFQN
                     {
                      
                     	        newCompositeNode(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); 
@@ -21035,7 +21160,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8416:7: otherlv_3= 'model'
+                    // InternalRoom.g:8454:7: otherlv_3= 'model'
                     {
                     otherlv_3=(Token)match(input,116,FOLLOW_12); 
 
@@ -21047,11 +21172,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:8458:2: ( (lv_importURI_4_0= RULE_STRING ) )
+            // InternalRoom.g:8459: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:8459:1: (lv_importURI_4_0= RULE_STRING )
+            // InternalRoom.g:8460:3: lv_importURI_4_0= RULE_STRING
             {
             lv_importURI_4_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
 
@@ -21094,7 +21219,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleImportedFQN"
-    // InternalRoom.g:8446:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
+    // InternalRoom.g:8484:1: entryRuleImportedFQN returns [String current=null] : iv_ruleImportedFQN= ruleImportedFQN EOF ;
     public final String entryRuleImportedFQN() throws RecognitionException {
         String current = null;
 
@@ -21102,8 +21227,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:8485:2: (iv_ruleImportedFQN= ruleImportedFQN EOF )
+            // InternalRoom.g:8486:2: iv_ruleImportedFQN= ruleImportedFQN EOF
             {
              newCompositeNode(grammarAccess.getImportedFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -21130,7 +21255,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:8493:1: ruleImportedFQN returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FQN_0= ruleFQN (kw= '.*' )? ) ;
     public final AntlrDatatypeRuleToken ruleImportedFQN() throws RecognitionException {
         AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
 
@@ -21141,11 +21266,11 @@ 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:8496:28: ( (this_FQN_0= ruleFQN (kw= '.*' )? ) )
+            // InternalRoom.g:8497: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:8497:1: (this_FQN_0= ruleFQN (kw= '.*' )? )
+            // InternalRoom.g:8498:5: this_FQN_0= ruleFQN (kw= '.*' )?
             {
              
                     newCompositeNode(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); 
@@ -21161,16 +21286,16 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
                     afterParserOrEnumRuleCall();
                 
-            // InternalRoom.g:8470:1: (kw= '.*' )?
-            int alt175=2;
-            int LA175_0 = input.LA(1);
+            // InternalRoom.g:8508:1: (kw= '.*' )?
+            int alt176=2;
+            int LA176_0 = input.LA(1);
 
-            if ( (LA175_0==117) ) {
-                alt175=1;
+            if ( (LA176_0==117) ) {
+                alt176=1;
             }
-            switch (alt175) {
+            switch (alt176) {
                 case 1 :
-                    // InternalRoom.g:8471:2: kw= '.*'
+                    // InternalRoom.g:8509:2: kw= '.*'
                     {
                     kw=(Token)match(input,117,FOLLOW_2); 
 
@@ -21204,7 +21329,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDocumentation"
-    // InternalRoom.g:8484:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
+    // InternalRoom.g:8522:1: entryRuleDocumentation returns [EObject current=null] : iv_ruleDocumentation= ruleDocumentation EOF ;
     public final EObject entryRuleDocumentation() throws RecognitionException {
         EObject current = null;
 
@@ -21212,8 +21337,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:8523:2: (iv_ruleDocumentation= ruleDocumentation EOF )
+            // InternalRoom.g:8524:2: iv_ruleDocumentation= ruleDocumentation EOF
             {
              newCompositeNode(grammarAccess.getDocumentationRule()); 
             pushFollow(FOLLOW_1);
@@ -21240,7 +21365,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:8531: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 +21376,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:8534:28: ( ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' ) )
+            // InternalRoom.g:8535: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:8535:1: ( () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']' )
+            // InternalRoom.g:8535:2: () otherlv_1= '[' ( (lv_lines_2_0= RULE_STRING ) )* otherlv_3= ']'
             {
-            // InternalRoom.g:8497:2: ()
-            // InternalRoom.g:8498:5: 
+            // InternalRoom.g:8535:2: ()
+            // InternalRoom.g:8536:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21272,23 +21397,23 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
                 	newLeafNode(otherlv_1, grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1());
                 
-            // InternalRoom.g:8507:1: ( (lv_lines_2_0= RULE_STRING ) )*
-            loop176:
+            // InternalRoom.g:8545:1: ( (lv_lines_2_0= RULE_STRING ) )*
+            loop177:
             do {
-                int alt176=2;
-                int LA176_0 = input.LA(1);
+                int alt177=2;
+                int LA177_0 = input.LA(1);
 
-                if ( (LA176_0==RULE_STRING) ) {
-                    alt176=1;
+                if ( (LA177_0==RULE_STRING) ) {
+                    alt177=1;
                 }
 
 
-                switch (alt176) {
+                switch (alt177) {
             	case 1 :
-            	    // InternalRoom.g:8508:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalRoom.g:8546: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:8546:1: (lv_lines_2_0= RULE_STRING )
+            	    // InternalRoom.g:8547:3: lv_lines_2_0= RULE_STRING
             	    {
             	    lv_lines_2_0=(Token)match(input,RULE_STRING,FOLLOW_148); 
 
@@ -21312,7 +21437,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop176;
+            	    break loop177;
                 }
             } while (true);
 
@@ -21341,7 +21466,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleLiteral"
-    // InternalRoom.g:8541:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+    // InternalRoom.g:8579:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
     public final EObject entryRuleLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21349,8 +21474,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:8580:2: (iv_ruleLiteral= ruleLiteral EOF )
+            // InternalRoom.g:8581:2: iv_ruleLiteral= ruleLiteral EOF
             {
              newCompositeNode(grammarAccess.getLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21377,7 +21502,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:8588: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 +21516,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:8591:28: ( (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral ) )
+            // InternalRoom.g:8592: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:8592:1: (this_BooleanLiteral_0= ruleBooleanLiteral | this_NumberLiteral_1= ruleNumberLiteral | this_StringLiteral_2= ruleStringLiteral )
+            int alt178=3;
             switch ( input.LA(1) ) {
             case 118:
             case 119:
                 {
-                alt177=1;
+                alt178=1;
                 }
                 break;
             case RULE_INT:
@@ -21408,24 +21533,24 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             case 120:
             case 121:
                 {
-                alt177=2;
+                alt178=2;
                 }
                 break;
             case RULE_STRING:
                 {
-                alt177=3;
+                alt178=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 177, 0, input);
+                    new NoViableAltException("", 178, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt177) {
+            switch (alt178) {
                 case 1 :
-                    // InternalRoom.g:8555:5: this_BooleanLiteral_0= ruleBooleanLiteral
+                    // InternalRoom.g:8593:5: this_BooleanLiteral_0= ruleBooleanLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); 
@@ -21443,7 +21568,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8565:5: this_NumberLiteral_1= ruleNumberLiteral
+                    // InternalRoom.g:8603:5: this_NumberLiteral_1= ruleNumberLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); 
@@ -21461,7 +21586,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:8575:5: this_StringLiteral_2= ruleStringLiteral
+                    // InternalRoom.g:8613:5: this_StringLiteral_2= ruleStringLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); 
@@ -21499,7 +21624,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleBooleanLiteral"
-    // InternalRoom.g:8591:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
+    // InternalRoom.g:8629:1: entryRuleBooleanLiteral returns [EObject current=null] : iv_ruleBooleanLiteral= ruleBooleanLiteral EOF ;
     public final EObject entryRuleBooleanLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21507,8 +21632,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:8630:2: (iv_ruleBooleanLiteral= ruleBooleanLiteral EOF )
+            // InternalRoom.g:8631:2: iv_ruleBooleanLiteral= ruleBooleanLiteral EOF
             {
              newCompositeNode(grammarAccess.getBooleanLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21535,7 +21660,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:8638: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 +21670,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:8641:28: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
+            // InternalRoom.g:8642: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:8642:1: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalRoom.g:8642:2: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
             {
-            // InternalRoom.g:8604:2: ()
-            // InternalRoom.g:8605:5: 
+            // InternalRoom.g:8642:2: ()
+            // InternalRoom.g:8643:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21562,25 +21687,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:8648:2: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            int alt179=2;
+            int LA179_0 = input.LA(1);
 
-            if ( (LA178_0==118) ) {
-                alt178=1;
+            if ( (LA179_0==118) ) {
+                alt179=1;
             }
-            else if ( (LA178_0==119) ) {
-                alt178=2;
+            else if ( (LA179_0==119) ) {
+                alt179=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 178, 0, input);
+                    new NoViableAltException("", 179, 0, input);
 
                 throw nvae;
             }
-            switch (alt178) {
+            switch (alt179) {
                 case 1 :
-                    // InternalRoom.g:8610:4: otherlv_1= 'false'
+                    // InternalRoom.g:8648:4: otherlv_1= 'false'
                     {
                     otherlv_1=(Token)match(input,118,FOLLOW_2); 
 
@@ -21590,13 +21715,13 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8615:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalRoom.g:8653: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:8653:6: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalRoom.g:8654: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:8654:1: (lv_isTrue_2_0= 'true' )
+                    // InternalRoom.g:8655:3: lv_isTrue_2_0= 'true'
                     {
                     lv_isTrue_2_0=(Token)match(input,119,FOLLOW_2); 
 
@@ -21641,7 +21766,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleNumberLiteral"
-    // InternalRoom.g:8638:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
+    // InternalRoom.g:8676:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
     public final EObject entryRuleNumberLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21649,8 +21774,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:8677:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
+            // InternalRoom.g:8678:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
             {
              newCompositeNode(grammarAccess.getNumberLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21677,7 +21802,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:8685: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 +21814,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:8688:28: ( (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral ) )
+            // InternalRoom.g:8689: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:8689:1: (this_IntLiteral_0= ruleIntLiteral | this_RealLiteral_1= ruleRealLiteral )
+            int alt180=2;
             switch ( input.LA(1) ) {
             case 120:
                 {
-                int LA179_1 = input.LA(2);
+                int LA180_1 = input.LA(2);
 
-                if ( (LA179_1==RULE_INT) ) {
-                    int LA179_3 = input.LA(3);
+                if ( (LA180_1==RULE_INT) ) {
+                    int LA180_3 = input.LA(3);
 
-                    if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                        alt179=1;
+                    if ( (LA180_3==EOF||LA180_3==21||LA180_3==25) ) {
+                        alt180=1;
                     }
-                    else if ( (LA179_3==72) ) {
-                        alt179=2;
+                    else if ( (LA180_3==72) ) {
+                        alt180=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 179, 3, input);
+                            new NoViableAltException("", 180, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 1, input);
+                        new NoViableAltException("", 180, 1, input);
 
                     throw nvae;
                 }
@@ -21725,27 +21850,27 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 121:
                 {
-                int LA179_2 = input.LA(2);
+                int LA180_2 = input.LA(2);
 
-                if ( (LA179_2==RULE_INT) ) {
-                    int LA179_3 = input.LA(3);
+                if ( (LA180_2==RULE_INT) ) {
+                    int LA180_3 = input.LA(3);
 
-                    if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                        alt179=1;
+                    if ( (LA180_3==EOF||LA180_3==21||LA180_3==25) ) {
+                        alt180=1;
                     }
-                    else if ( (LA179_3==72) ) {
-                        alt179=2;
+                    else if ( (LA180_3==72) ) {
+                        alt180=2;
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 179, 3, input);
+                            new NoViableAltException("", 180, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 2, input);
+                        new NoViableAltException("", 180, 2, input);
 
                     throw nvae;
                 }
@@ -21753,17 +21878,17 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA179_3 = input.LA(2);
+                int LA180_3 = input.LA(2);
 
-                if ( (LA179_3==EOF||LA179_3==21||LA179_3==25) ) {
-                    alt179=1;
+                if ( (LA180_3==EOF||LA180_3==21||LA180_3==25) ) {
+                    alt180=1;
                 }
-                else if ( (LA179_3==72) ) {
-                    alt179=2;
+                else if ( (LA180_3==72) ) {
+                    alt180=2;
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 179, 3, input);
+                        new NoViableAltException("", 180, 3, input);
 
                     throw nvae;
                 }
@@ -21771,19 +21896,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_HEX:
                 {
-                alt179=1;
+                alt180=1;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 179, 0, input);
+                    new NoViableAltException("", 180, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt179) {
+            switch (alt180) {
                 case 1 :
-                    // InternalRoom.g:8652:5: this_IntLiteral_0= ruleIntLiteral
+                    // InternalRoom.g:8690:5: this_IntLiteral_0= ruleIntLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); 
@@ -21801,7 +21926,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8662:5: this_RealLiteral_1= ruleRealLiteral
+                    // InternalRoom.g:8700:5: this_RealLiteral_1= ruleRealLiteral
                     {
                      
                             newCompositeNode(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); 
@@ -21839,7 +21964,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleRealLiteral"
-    // InternalRoom.g:8678:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
+    // InternalRoom.g:8716:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ;
     public final EObject entryRuleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21847,8 +21972,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:8717:2: (iv_ruleRealLiteral= ruleRealLiteral EOF )
+            // InternalRoom.g:8718:2: iv_ruleRealLiteral= ruleRealLiteral EOF
             {
              newCompositeNode(grammarAccess.getRealLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21875,7 +22000,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:8725:1: ruleRealLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleReal ) ) ) ;
     public final EObject ruleRealLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21885,14 +22010,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:8728:28: ( ( () ( (lv_value_1_0= ruleReal ) ) ) )
+            // InternalRoom.g:8729: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:8729:1: ( () ( (lv_value_1_0= ruleReal ) ) )
+            // InternalRoom.g:8729:2: () ( (lv_value_1_0= ruleReal ) )
             {
-            // InternalRoom.g:8691:2: ()
-            // InternalRoom.g:8692:5: 
+            // InternalRoom.g:8729:2: ()
+            // InternalRoom.g:8730:5: 
             {
 
                     current = forceCreateModelElement(
@@ -21902,11 +22027,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:8735:2: ( (lv_value_1_0= ruleReal ) )
+            // InternalRoom.g:8736: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:8736:1: (lv_value_1_0= ruleReal )
+            // InternalRoom.g:8737:3: lv_value_1_0= ruleReal
             {
              
             	        newCompositeNode(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); 
@@ -21954,7 +22079,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleIntLiteral"
-    // InternalRoom.g:8723:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
+    // InternalRoom.g:8761:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ;
     public final EObject entryRuleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -21962,8 +22087,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:8762:2: (iv_ruleIntLiteral= ruleIntLiteral EOF )
+            // InternalRoom.g:8763:2: iv_ruleIntLiteral= ruleIntLiteral EOF
             {
              newCompositeNode(grammarAccess.getIntLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -21990,7 +22115,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:8770:1: ruleIntLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleInteger ) ) ) ;
     public final EObject ruleIntLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22000,14 +22125,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:8773:28: ( ( () ( (lv_value_1_0= ruleInteger ) ) ) )
+            // InternalRoom.g:8774: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:8774:1: ( () ( (lv_value_1_0= ruleInteger ) ) )
+            // InternalRoom.g:8774:2: () ( (lv_value_1_0= ruleInteger ) )
             {
-            // InternalRoom.g:8736:2: ()
-            // InternalRoom.g:8737:5: 
+            // InternalRoom.g:8774:2: ()
+            // InternalRoom.g:8775:5: 
             {
 
                     current = forceCreateModelElement(
@@ -22017,11 +22142,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:8780:2: ( (lv_value_1_0= ruleInteger ) )
+            // InternalRoom.g:8781: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:8781:1: (lv_value_1_0= ruleInteger )
+            // InternalRoom.g:8782:3: lv_value_1_0= ruleInteger
             {
              
             	        newCompositeNode(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); 
@@ -22069,7 +22194,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleStringLiteral"
-    // InternalRoom.g:8768:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
+    // InternalRoom.g:8806:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
     public final EObject entryRuleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22077,8 +22202,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:8807:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
+            // InternalRoom.g:8808:2: iv_ruleStringLiteral= ruleStringLiteral EOF
             {
              newCompositeNode(grammarAccess.getStringLiteralRule()); 
             pushFollow(FOLLOW_1);
@@ -22105,7 +22230,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:8815:1: ruleStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
     public final EObject ruleStringLiteral() throws RecognitionException {
         EObject current = null;
 
@@ -22114,14 +22239,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:8818:28: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
+            // InternalRoom.g:8819: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:8819:1: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalRoom.g:8819:2: () ( (lv_value_1_0= RULE_STRING ) )
             {
-            // InternalRoom.g:8781:2: ()
-            // InternalRoom.g:8782:5: 
+            // InternalRoom.g:8819:2: ()
+            // InternalRoom.g:8820:5: 
             {
 
                     current = forceCreateModelElement(
@@ -22131,11 +22256,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:8825:2: ( (lv_value_1_0= RULE_STRING ) )
+            // InternalRoom.g:8826: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:8826:1: (lv_value_1_0= RULE_STRING )
+            // InternalRoom.g:8827:3: lv_value_1_0= RULE_STRING
             {
             lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
 
@@ -22178,7 +22303,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleInteger"
-    // InternalRoom.g:8813:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
+    // InternalRoom.g:8851:1: entryRuleInteger returns [String current=null] : iv_ruleInteger= ruleInteger EOF ;
     public final String entryRuleInteger() throws RecognitionException {
         String current = null;
 
@@ -22186,8 +22311,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:8852:2: (iv_ruleInteger= ruleInteger EOF )
+            // InternalRoom.g:8853:2: iv_ruleInteger= ruleInteger EOF
             {
              newCompositeNode(grammarAccess.getIntegerRule()); 
             pushFollow(FOLLOW_1);
@@ -22214,7 +22339,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:8860: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 +22350,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:8863:28: ( ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX ) )
+            // InternalRoom.g:8864: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:8864:1: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT ) | this_HEX_3= RULE_HEX )
+            int alt182=2;
+            int LA182_0 = input.LA(1);
 
-            if ( (LA181_0==RULE_INT||(LA181_0>=120 && LA181_0<=121)) ) {
-                alt181=1;
+            if ( (LA182_0==RULE_INT||(LA182_0>=120 && LA182_0<=121)) ) {
+                alt182=1;
             }
-            else if ( (LA181_0==RULE_HEX) ) {
-                alt181=2;
+            else if ( (LA182_0==RULE_HEX) ) {
+                alt182=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 181, 0, input);
+                    new NoViableAltException("", 182, 0, input);
 
                 throw nvae;
             }
-            switch (alt181) {
+            switch (alt182) {
                 case 1 :
-                    // InternalRoom.g:8826:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalRoom.g:8864: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:8864:2: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT )
+                    // InternalRoom.g:8864: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:8864:3: (kw= '+' | kw= '-' )?
+                    int alt181=3;
+                    int LA181_0 = input.LA(1);
 
-                    if ( (LA180_0==120) ) {
-                        alt180=1;
+                    if ( (LA181_0==120) ) {
+                        alt181=1;
                     }
-                    else if ( (LA180_0==121) ) {
-                        alt180=2;
+                    else if ( (LA181_0==121) ) {
+                        alt181=2;
                     }
-                    switch (alt180) {
+                    switch (alt181) {
                         case 1 :
-                            // InternalRoom.g:8827:2: kw= '+'
+                            // InternalRoom.g:8865:2: kw= '+'
                             {
                             kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22274,7 +22399,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                             }
                             break;
                         case 2 :
-                            // InternalRoom.g:8834:2: kw= '-'
+                            // InternalRoom.g:8872:2: kw= '-'
                             {
                             kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22301,7 +22426,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8847:10: this_HEX_3= RULE_HEX
+                    // InternalRoom.g:8885:10: this_HEX_3= RULE_HEX
                     {
                     this_HEX_3=(Token)match(input,RULE_HEX,FOLLOW_2); 
 
@@ -22334,7 +22459,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleReal"
-    // InternalRoom.g:8862:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
+    // InternalRoom.g:8900:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ;
     public final String entryRuleReal() throws RecognitionException {
         String current = null;
 
@@ -22342,8 +22467,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:8901:2: (iv_ruleReal= ruleReal EOF )
+            // InternalRoom.g:8902:2: iv_ruleReal= ruleReal EOF
             {
              newCompositeNode(grammarAccess.getRealRule()); 
             pushFollow(FOLLOW_1);
@@ -22370,7 +22495,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:8909: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 +22507,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:8912:28: ( (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp ) )
+            // InternalRoom.g:8913: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:8913:1: (this_Decimal_0= ruleDecimal | this_DecimalExp_1= ruleDecimalExp )
+            int alt183=2;
             switch ( input.LA(1) ) {
             case 120:
                 {
-                int LA182_1 = input.LA(2);
+                int LA183_1 = input.LA(2);
 
-                if ( (LA182_1==RULE_INT) ) {
-                    int LA182_3 = input.LA(3);
+                if ( (LA183_1==RULE_INT) ) {
+                    int LA183_3 = input.LA(3);
 
-                    if ( (LA182_3==72) ) {
-                        int LA182_4 = input.LA(4);
+                    if ( (LA183_3==72) ) {
+                        int LA183_4 = input.LA(4);
 
-                        if ( (LA182_4==RULE_INT) ) {
-                            int LA182_5 = input.LA(5);
+                        if ( (LA183_4==RULE_INT) ) {
+                            int LA183_5 = input.LA(5);
 
-                            if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                                alt182=1;
+                            if ( (LA183_5==EOF||LA183_5==21||LA183_5==25) ) {
+                                alt183=1;
                             }
-                            else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                                alt182=2;
+                            else if ( ((LA183_5>=122 && LA183_5<=123)) ) {
+                                alt183=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 182, 5, input);
+                                    new NoViableAltException("", 183, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 4, input);
+                                new NoViableAltException("", 183, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 3, input);
+                            new NoViableAltException("", 183, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 1, input);
+                        new NoViableAltException("", 183, 1, input);
 
                     throw nvae;
                 }
@@ -22438,47 +22563,47 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case 121:
                 {
-                int LA182_2 = input.LA(2);
+                int LA183_2 = input.LA(2);
 
-                if ( (LA182_2==RULE_INT) ) {
-                    int LA182_3 = input.LA(3);
+                if ( (LA183_2==RULE_INT) ) {
+                    int LA183_3 = input.LA(3);
 
-                    if ( (LA182_3==72) ) {
-                        int LA182_4 = input.LA(4);
+                    if ( (LA183_3==72) ) {
+                        int LA183_4 = input.LA(4);
 
-                        if ( (LA182_4==RULE_INT) ) {
-                            int LA182_5 = input.LA(5);
+                        if ( (LA183_4==RULE_INT) ) {
+                            int LA183_5 = input.LA(5);
 
-                            if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                                alt182=1;
+                            if ( (LA183_5==EOF||LA183_5==21||LA183_5==25) ) {
+                                alt183=1;
                             }
-                            else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                                alt182=2;
+                            else if ( ((LA183_5>=122 && LA183_5<=123)) ) {
+                                alt183=2;
                             }
                             else {
                                 NoViableAltException nvae =
-                                    new NoViableAltException("", 182, 5, input);
+                                    new NoViableAltException("", 183, 5, input);
 
                                 throw nvae;
                             }
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 4, input);
+                                new NoViableAltException("", 183, 4, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 3, input);
+                            new NoViableAltException("", 183, 3, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 2, input);
+                        new NoViableAltException("", 183, 2, input);
 
                     throw nvae;
                 }
@@ -22486,37 +22611,37 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             case RULE_INT:
                 {
-                int LA182_3 = input.LA(2);
+                int LA183_3 = input.LA(2);
 
-                if ( (LA182_3==72) ) {
-                    int LA182_4 = input.LA(3);
+                if ( (LA183_3==72) ) {
+                    int LA183_4 = input.LA(3);
 
-                    if ( (LA182_4==RULE_INT) ) {
-                        int LA182_5 = input.LA(4);
+                    if ( (LA183_4==RULE_INT) ) {
+                        int LA183_5 = input.LA(4);
 
-                        if ( (LA182_5==EOF||LA182_5==21||LA182_5==25) ) {
-                            alt182=1;
+                        if ( (LA183_5==EOF||LA183_5==21||LA183_5==25) ) {
+                            alt183=1;
                         }
-                        else if ( ((LA182_5>=122 && LA182_5<=123)) ) {
-                            alt182=2;
+                        else if ( ((LA183_5>=122 && LA183_5<=123)) ) {
+                            alt183=2;
                         }
                         else {
                             NoViableAltException nvae =
-                                new NoViableAltException("", 182, 5, input);
+                                new NoViableAltException("", 183, 5, input);
 
                             throw nvae;
                         }
                     }
                     else {
                         NoViableAltException nvae =
-                            new NoViableAltException("", 182, 4, input);
+                            new NoViableAltException("", 183, 4, input);
 
                         throw nvae;
                     }
                 }
                 else {
                     NoViableAltException nvae =
-                        new NoViableAltException("", 182, 3, input);
+                        new NoViableAltException("", 183, 3, input);
 
                     throw nvae;
                 }
@@ -22524,14 +22649,14 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 182, 0, input);
+                    new NoViableAltException("", 183, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt182) {
+            switch (alt183) {
                 case 1 :
-                    // InternalRoom.g:8876:5: this_Decimal_0= ruleDecimal
+                    // InternalRoom.g:8914:5: this_Decimal_0= ruleDecimal
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); 
@@ -22551,7 +22676,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8888:5: this_DecimalExp_1= ruleDecimalExp
+                    // InternalRoom.g:8926:5: this_DecimalExp_1= ruleDecimalExp
                     {
                      
                             newCompositeNode(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); 
@@ -22591,7 +22716,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimal"
-    // InternalRoom.g:8906:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
+    // InternalRoom.g:8944:1: entryRuleDecimal returns [String current=null] : iv_ruleDecimal= ruleDecimal EOF ;
     public final String entryRuleDecimal() throws RecognitionException {
         String current = null;
 
@@ -22602,8 +22727,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:8948:2: (iv_ruleDecimal= ruleDecimal EOF )
+            // InternalRoom.g:8949:2: iv_ruleDecimal= ruleDecimal EOF
             {
              newCompositeNode(grammarAccess.getDecimalRule()); 
             pushFollow(FOLLOW_1);
@@ -22633,7 +22758,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:8959: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 +22770,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:8963:28: ( ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT ) )
+            // InternalRoom.g:8964: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:8964:1: ( (kw= '+' | kw= '-' )? this_INT_2= RULE_INT kw= '.' this_INT_4= RULE_INT )
+            // InternalRoom.g:8964: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:8964:2: (kw= '+' | kw= '-' )?
+            int alt184=3;
+            int LA184_0 = input.LA(1);
 
-            if ( (LA183_0==120) ) {
-                alt183=1;
+            if ( (LA184_0==120) ) {
+                alt184=1;
             }
-            else if ( (LA183_0==121) ) {
-                alt183=2;
+            else if ( (LA184_0==121) ) {
+                alt184=2;
             }
-            switch (alt183) {
+            switch (alt184) {
                 case 1 :
-                    // InternalRoom.g:8927:2: kw= '+'
+                    // InternalRoom.g:8965:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22674,7 +22799,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8934:2: kw= '-'
+                    // InternalRoom.g:8972:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22730,7 +22855,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleDecimalExp"
-    // InternalRoom.g:8970:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
+    // InternalRoom.g:9008:1: entryRuleDecimalExp returns [String current=null] : iv_ruleDecimalExp= ruleDecimalExp EOF ;
     public final String entryRuleDecimalExp() throws RecognitionException {
         String current = null;
 
@@ -22741,8 +22866,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:9012:2: (iv_ruleDecimalExp= ruleDecimalExp EOF )
+            // InternalRoom.g:9013:2: iv_ruleDecimalExp= ruleDecimalExp EOF
             {
              newCompositeNode(grammarAccess.getDecimalExpRule()); 
             pushFollow(FOLLOW_1);
@@ -22772,7 +22897,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:9023: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 +22910,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:9027: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:9028: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:9028: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:9028: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:9028:2: (kw= '+' | kw= '-' )?
+            int alt185=3;
+            int LA185_0 = input.LA(1);
 
-            if ( (LA184_0==120) ) {
-                alt184=1;
+            if ( (LA185_0==120) ) {
+                alt185=1;
             }
-            else if ( (LA184_0==121) ) {
-                alt184=2;
+            else if ( (LA185_0==121) ) {
+                alt185=2;
             }
-            switch (alt184) {
+            switch (alt185) {
                 case 1 :
-                    // InternalRoom.g:8991:2: kw= '+'
+                    // InternalRoom.g:9029:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22814,7 +22939,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:8998:2: kw= '-'
+                    // InternalRoom.g:9036:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22846,25 +22971,25 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
                 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:9061:1: (kw= 'e' | kw= 'E' )
+            int alt186=2;
+            int LA186_0 = input.LA(1);
 
-            if ( (LA185_0==122) ) {
-                alt185=1;
+            if ( (LA186_0==122) ) {
+                alt186=1;
             }
-            else if ( (LA185_0==123) ) {
-                alt185=2;
+            else if ( (LA186_0==123) ) {
+                alt186=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 185, 0, input);
+                    new NoViableAltException("", 186, 0, input);
 
                 throw nvae;
             }
-            switch (alt185) {
+            switch (alt186) {
                 case 1 :
-                    // InternalRoom.g:9024:2: kw= 'e'
+                    // InternalRoom.g:9062:2: kw= 'e'
                     {
                     kw=(Token)match(input,122,FOLLOW_150); 
 
@@ -22875,7 +23000,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9031:2: kw= 'E'
+                    // InternalRoom.g:9069:2: kw= 'E'
                     {
                     kw=(Token)match(input,123,FOLLOW_150); 
 
@@ -22888,19 +23013,19 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
             }
 
-            // InternalRoom.g:9036:2: (kw= '+' | kw= '-' )?
-            int alt186=3;
-            int LA186_0 = input.LA(1);
+            // InternalRoom.g:9074:2: (kw= '+' | kw= '-' )?
+            int alt187=3;
+            int LA187_0 = input.LA(1);
 
-            if ( (LA186_0==120) ) {
-                alt186=1;
+            if ( (LA187_0==120) ) {
+                alt187=1;
             }
-            else if ( (LA186_0==121) ) {
-                alt186=2;
+            else if ( (LA187_0==121) ) {
+                alt187=2;
             }
-            switch (alt186) {
+            switch (alt187) {
                 case 1 :
-                    // InternalRoom.g:9037:2: kw= '+'
+                    // InternalRoom.g:9075:2: kw= '+'
                     {
                     kw=(Token)match(input,120,FOLLOW_34); 
 
@@ -22911,7 +23036,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9044:2: kw= '-'
+                    // InternalRoom.g:9082:2: kw= '-'
                     {
                     kw=(Token)match(input,121,FOLLOW_34); 
 
@@ -22955,7 +23080,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
 
 
     // $ANTLR start "entryRuleFQN"
-    // InternalRoom.g:9067:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
+    // InternalRoom.g:9105:1: entryRuleFQN returns [String current=null] : iv_ruleFQN= ruleFQN EOF ;
     public final String entryRuleFQN() throws RecognitionException {
         String current = null;
 
@@ -22963,8 +23088,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:9106:2: (iv_ruleFQN= ruleFQN EOF )
+            // InternalRoom.g:9107:2: iv_ruleFQN= ruleFQN EOF
             {
              newCompositeNode(grammarAccess.getFQNRule()); 
             pushFollow(FOLLOW_1);
@@ -22991,7 +23116,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:9114: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,11 +23127,11 @@ 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:9117:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
+            // InternalRoom.g:9118: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:9118:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
+            // InternalRoom.g:9118:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
             {
             this_ID_0=(Token)match(input,RULE_ID,FOLLOW_151); 
 
@@ -23015,20 +23140,20 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
              
                 newLeafNode(this_ID_0, grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); 
                 
-            // InternalRoom.g:9087:1: (kw= '.' this_ID_2= RULE_ID )*
-            loop187:
+            // InternalRoom.g:9125:1: (kw= '.' this_ID_2= RULE_ID )*
+            loop188:
             do {
-                int alt187=2;
-                int LA187_0 = input.LA(1);
+                int alt188=2;
+                int LA188_0 = input.LA(1);
 
-                if ( (LA187_0==72) ) {
-                    alt187=1;
+                if ( (LA188_0==72) ) {
+                    alt188=1;
                 }
 
 
-                switch (alt187) {
+                switch (alt188) {
             	case 1 :
-            	    // InternalRoom.g:9088:2: kw= '.' this_ID_2= RULE_ID
+            	    // InternalRoom.g:9126:2: kw= '.' this_ID_2= RULE_ID
             	    {
             	    kw=(Token)match(input,72,FOLLOW_3); 
 
@@ -23047,7 +23172,7 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             	    break;
 
             	default :
-            	    break loop187;
+            	    break loop188;
                 }
             } while (true);
 
@@ -23072,7 +23197,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:9146: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 +23207,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:9148:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) ) )
+            // InternalRoom.g:9149: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:9149:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'sync' ) )
+            int alt189=3;
             switch ( input.LA(1) ) {
             case 124:
                 {
-                alt188=1;
+                alt189=1;
                 }
                 break;
             case 125:
                 {
-                alt188=2;
+                alt189=2;
                 }
                 break;
             case 126:
                 {
-                alt188=3;
+                alt189=3;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 188, 0, input);
+                    new NoViableAltException("", 189, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt188) {
+            switch (alt189) {
                 case 1 :
-                    // InternalRoom.g:9111:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9149:2: (enumLiteral_0= 'eventdriven' )
                     {
-                    // InternalRoom.g:9111:2: (enumLiteral_0= 'eventdriven' )
-                    // InternalRoom.g:9111:4: enumLiteral_0= 'eventdriven'
+                    // InternalRoom.g:9149:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9149:4: enumLiteral_0= 'eventdriven'
                     {
                     enumLiteral_0=(Token)match(input,124,FOLLOW_2); 
 
@@ -23129,10 +23254,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9117:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9155:6: (enumLiteral_1= 'datadriven' )
                     {
-                    // InternalRoom.g:9117:6: (enumLiteral_1= 'datadriven' )
-                    // InternalRoom.g:9117:8: enumLiteral_1= 'datadriven'
+                    // InternalRoom.g:9155:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9155:8: enumLiteral_1= 'datadriven'
                     {
                     enumLiteral_1=(Token)match(input,125,FOLLOW_2); 
 
@@ -23146,10 +23271,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9123:6: (enumLiteral_2= 'sync' )
+                    // InternalRoom.g:9161:6: (enumLiteral_2= 'sync' )
                     {
-                    // InternalRoom.g:9123:6: (enumLiteral_2= 'sync' )
-                    // InternalRoom.g:9123:8: enumLiteral_2= 'sync'
+                    // InternalRoom.g:9161:6: (enumLiteral_2= 'sync' )
+                    // InternalRoom.g:9161:8: enumLiteral_2= 'sync'
                     {
                     enumLiteral_2=(Token)match(input,126,FOLLOW_2); 
 
@@ -23183,7 +23308,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:9171:1: ruleReferenceType returns [Enumerator current=null] : ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) ;
     public final Enumerator ruleReferenceType() throws RecognitionException {
         Enumerator current = null;
 
@@ -23192,31 +23317,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:9173:28: ( ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) ) )
+            // InternalRoom.g:9174: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:9174:1: ( (enumLiteral_0= 'fixed' ) | (enumLiteral_1= 'optional' ) )
+            int alt190=2;
+            int LA190_0 = input.LA(1);
 
-            if ( (LA189_0==127) ) {
-                alt189=1;
+            if ( (LA190_0==127) ) {
+                alt190=1;
             }
-            else if ( (LA189_0==111) ) {
-                alt189=2;
+            else if ( (LA190_0==111) ) {
+                alt190=2;
             }
             else {
                 NoViableAltException nvae =
-                    new NoViableAltException("", 189, 0, input);
+                    new NoViableAltException("", 190, 0, input);
 
                 throw nvae;
             }
-            switch (alt189) {
+            switch (alt190) {
                 case 1 :
-                    // InternalRoom.g:9136:2: (enumLiteral_0= 'fixed' )
+                    // InternalRoom.g:9174:2: (enumLiteral_0= 'fixed' )
                     {
-                    // InternalRoom.g:9136:2: (enumLiteral_0= 'fixed' )
-                    // InternalRoom.g:9136:4: enumLiteral_0= 'fixed'
+                    // InternalRoom.g:9174:2: (enumLiteral_0= 'fixed' )
+                    // InternalRoom.g:9174:4: enumLiteral_0= 'fixed'
                     {
                     enumLiteral_0=(Token)match(input,127,FOLLOW_2); 
 
@@ -23230,10 +23355,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9142:6: (enumLiteral_1= 'optional' )
+                    // InternalRoom.g:9180:6: (enumLiteral_1= 'optional' )
                     {
-                    // InternalRoom.g:9142:6: (enumLiteral_1= 'optional' )
-                    // InternalRoom.g:9142:8: enumLiteral_1= 'optional'
+                    // InternalRoom.g:9180:6: (enumLiteral_1= 'optional' )
+                    // InternalRoom.g:9180:8: enumLiteral_1= 'optional'
                     {
                     enumLiteral_1=(Token)match(input,111,FOLLOW_2); 
 
@@ -23267,7 +23392,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:9192: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 +23403,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:9194:28: ( ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) ) )
+            // InternalRoom.g:9195: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:9195:1: ( (enumLiteral_0= 'eventdriven' ) | (enumLiteral_1= 'datadriven' ) | (enumLiteral_2= 'async' ) | (enumLiteral_3= 'sync' ) )
+            int alt191=4;
             switch ( input.LA(1) ) {
             case 124:
                 {
-                alt190=1;
+                alt191=1;
                 }
                 break;
             case 125:
                 {
-                alt190=2;
+                alt191=2;
                 }
                 break;
             case 128:
                 {
-                alt190=3;
+                alt191=3;
                 }
                 break;
             case 126:
                 {
-                alt190=4;
+                alt191=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 190, 0, input);
+                    new NoViableAltException("", 191, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt190) {
+            switch (alt191) {
                 case 1 :
-                    // InternalRoom.g:9157:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9195:2: (enumLiteral_0= 'eventdriven' )
                     {
-                    // InternalRoom.g:9157:2: (enumLiteral_0= 'eventdriven' )
-                    // InternalRoom.g:9157:4: enumLiteral_0= 'eventdriven'
+                    // InternalRoom.g:9195:2: (enumLiteral_0= 'eventdriven' )
+                    // InternalRoom.g:9195:4: enumLiteral_0= 'eventdriven'
                     {
                     enumLiteral_0=(Token)match(input,124,FOLLOW_2); 
 
@@ -23330,10 +23455,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9163:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9201:6: (enumLiteral_1= 'datadriven' )
                     {
-                    // InternalRoom.g:9163:6: (enumLiteral_1= 'datadriven' )
-                    // InternalRoom.g:9163:8: enumLiteral_1= 'datadriven'
+                    // InternalRoom.g:9201:6: (enumLiteral_1= 'datadriven' )
+                    // InternalRoom.g:9201:8: enumLiteral_1= 'datadriven'
                     {
                     enumLiteral_1=(Token)match(input,125,FOLLOW_2); 
 
@@ -23347,10 +23472,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9169:6: (enumLiteral_2= 'async' )
+                    // InternalRoom.g:9207:6: (enumLiteral_2= 'async' )
                     {
-                    // InternalRoom.g:9169:6: (enumLiteral_2= 'async' )
-                    // InternalRoom.g:9169:8: enumLiteral_2= 'async'
+                    // InternalRoom.g:9207:6: (enumLiteral_2= 'async' )
+                    // InternalRoom.g:9207:8: enumLiteral_2= 'async'
                     {
                     enumLiteral_2=(Token)match(input,128,FOLLOW_2); 
 
@@ -23364,10 +23489,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:9175:6: (enumLiteral_3= 'sync' )
+                    // InternalRoom.g:9213:6: (enumLiteral_3= 'sync' )
                     {
-                    // InternalRoom.g:9175:6: (enumLiteral_3= 'sync' )
-                    // InternalRoom.g:9175:8: enumLiteral_3= 'sync'
+                    // InternalRoom.g:9213:6: (enumLiteral_3= 'sync' )
+                    // InternalRoom.g:9213:8: enumLiteral_3= 'sync'
                     {
                     enumLiteral_3=(Token)match(input,126,FOLLOW_2); 
 
@@ -23401,7 +23526,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:9223: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 +23537,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:9225:28: ( ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) ) )
+            // InternalRoom.g:9226: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:9226:1: ( (enumLiteral_0= 'ptBoolean' ) | (enumLiteral_1= 'ptInteger' ) | (enumLiteral_2= 'ptReal' ) | (enumLiteral_3= 'ptCharacter' ) )
+            int alt192=4;
             switch ( input.LA(1) ) {
             case 129:
                 {
-                alt191=1;
+                alt192=1;
                 }
                 break;
             case 130:
                 {
-                alt191=2;
+                alt192=2;
                 }
                 break;
             case 131:
                 {
-                alt191=3;
+                alt192=3;
                 }
                 break;
             case 132:
                 {
-                alt191=4;
+                alt192=4;
                 }
                 break;
             default:
                 NoViableAltException nvae =
-                    new NoViableAltException("", 191, 0, input);
+                    new NoViableAltException("", 192, 0, input);
 
                 throw nvae;
             }
 
-            switch (alt191) {
+            switch (alt192) {
                 case 1 :
-                    // InternalRoom.g:9188:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalRoom.g:9226:2: (enumLiteral_0= 'ptBoolean' )
                     {
-                    // InternalRoom.g:9188:2: (enumLiteral_0= 'ptBoolean' )
-                    // InternalRoom.g:9188:4: enumLiteral_0= 'ptBoolean'
+                    // InternalRoom.g:9226:2: (enumLiteral_0= 'ptBoolean' )
+                    // InternalRoom.g:9226:4: enumLiteral_0= 'ptBoolean'
                     {
                     enumLiteral_0=(Token)match(input,129,FOLLOW_2); 
 
@@ -23464,10 +23589,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 2 :
-                    // InternalRoom.g:9194:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalRoom.g:9232:6: (enumLiteral_1= 'ptInteger' )
                     {
-                    // InternalRoom.g:9194:6: (enumLiteral_1= 'ptInteger' )
-                    // InternalRoom.g:9194:8: enumLiteral_1= 'ptInteger'
+                    // InternalRoom.g:9232:6: (enumLiteral_1= 'ptInteger' )
+                    // InternalRoom.g:9232:8: enumLiteral_1= 'ptInteger'
                     {
                     enumLiteral_1=(Token)match(input,130,FOLLOW_2); 
 
@@ -23481,10 +23606,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 3 :
-                    // InternalRoom.g:9200:6: (enumLiteral_2= 'ptReal' )
+                    // InternalRoom.g:9238:6: (enumLiteral_2= 'ptReal' )
                     {
-                    // InternalRoom.g:9200:6: (enumLiteral_2= 'ptReal' )
-                    // InternalRoom.g:9200:8: enumLiteral_2= 'ptReal'
+                    // InternalRoom.g:9238:6: (enumLiteral_2= 'ptReal' )
+                    // InternalRoom.g:9238:8: enumLiteral_2= 'ptReal'
                     {
                     enumLiteral_2=(Token)match(input,131,FOLLOW_2); 
 
@@ -23498,10 +23623,10 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
                     }
                     break;
                 case 4 :
-                    // InternalRoom.g:9206:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalRoom.g:9244:6: (enumLiteral_3= 'ptCharacter' )
                     {
-                    // InternalRoom.g:9206:6: (enumLiteral_3= 'ptCharacter' )
-                    // InternalRoom.g:9206:8: enumLiteral_3= 'ptCharacter'
+                    // InternalRoom.g:9244:6: (enumLiteral_3= 'ptCharacter' )
+                    // InternalRoom.g:9244:8: enumLiteral_3= 'ptCharacter'
                     {
                     enumLiteral_3=(Token)match(input,132,FOLLOW_2); 
 
@@ -23537,8 +23662,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 DFA134 dfa134 = new DFA134(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,10 +23711,10 @@ 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 = "\13\uffff\1\22\7\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\2\23\1\16\2\4\1\23\1\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\2\4\1\145\1\4\2\23\1\143\2\4\1\23\1\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",
@@ -23603,21 +23728,21 @@ public class InternalRoomParser extends AbstractInternalAntlrParser {
             "\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\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 +23753,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 DFA133 extends DFA {
 
-        public DFA132(BaseRecognizer recognizer) {
+        public DFA133(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 132;
+            this.decisionNumber = 133;
             this.eot = dfa_7;
             this.eof = dfa_8;
             this.min = dfa_9;
@@ -23642,32 +23767,32 @@ 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 "6216: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\2\23\1\16\2\4\1\23\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\2\4\1\145\1\4\2\23\1\42\2\4\1\23\1\43\1\141\1\4\2\42\1\43\1\16\2\uffff\1\42";
+    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\13\uffff\1\3",
             "\1\3",
             "\1\4\137\uffff\1\5\1\6",
-            "\1\10\4\uffff\1\7",
+            "\1\7\4\uffff\1\10",
             "\1\11",
             "\1\12",
-            "\1\13",
-            "\1\14\137\uffff\1\15\1\16",
-            "\1\10",
-            "\1\10",
-            "\1\10",
+            "\1\13\137\uffff\1\14\1\15",
+            "\1\16",
+            "\1\7",
+            "\1\7",
             "\1\20\11\uffff\1\21\11\uffff\1\17",
             "\1\22",
             "\1\23",
+            "\1\7",
             "\1\24\35\uffff\1\25",
-            "\1\27\1\uffff\1\26",
+            "\1\26\1\uffff\1\27",
             "\1\30",
             "\1\20\23\uffff\1\17",
             "\1\20\23\uffff\1\17",
@@ -23685,11 +23810,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 DFA134 extends DFA {
 
-        public DFA133(BaseRecognizer recognizer) {
+        public DFA134(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
-            this.decisionNumber = 133;
+            this.decisionNumber = 134;
             this.eot = dfa_14;
             this.eof = dfa_14;
             this.min = dfa_15;
@@ -23699,7 +23824,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 "6266:1: (this_TriggeredTransition_0= ruleTriggeredTransition | this_GuardedTransition_1= ruleGuardedTransition )";
         }
     }
  
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..3443ed454 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
@@ -370,24 +370,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? 
+	 *         connections+=LayerConnection? 
 	 *         (
 	 *             (
-	 *                 connections+=LayerConnection | 
 	 *                 bindings+=Binding | 
 	 *                 serviceImplementations+=ServiceImplementation | 
+	 *                 attributes+=Attribute | 
 	 *                 actorRefs+=ActorRef | 
 	 *                 serviceAccessPoints+=SAP | 
 	 *                 internalPorts+=Port | 
 	 *                 externalPorts+=ExternalPort
 	 *             )? 
-	 *             attributes+=Attribute?
+	 *             connections+=LayerConnection?
 	 *         )* 
 	 *         behaviorDocu=Documentation? 
 	 *         behaviorAnnotations+=Annotation* 
@@ -559,7 +559,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.EXTERNAL_PORT__INTERFACE_PORT));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1(), semanticObject.eGet(RoomPackage.Literals.EXTERNAL_PORT__INTERFACE_PORT, false));
+		feeder.accept(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1(), semanticObject.getInterfacePort());
 		feeder.finish();
 	}
 	
@@ -595,7 +595,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.MESSAGE_HANDLER__DETAIL_CODE));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1(), semanticObject.eGet(RoomPackage.Literals.MESSAGE_HANDLER__MSG, false));
+		feeder.accept(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1(), semanticObject.getMsg());
 		feeder.accept(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0(), semanticObject.getDetailCode());
 		feeder.finish();
 	}
@@ -682,7 +682,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.MESSAGE_HANDLER__DETAIL_CODE));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1(), semanticObject.eGet(RoomPackage.Literals.MESSAGE_HANDLER__MSG, false));
+		feeder.accept(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1(), semanticObject.getMsg());
 		feeder.accept(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0(), semanticObject.getDetailCode());
 		feeder.finish();
 	}
@@ -809,7 +809,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.REF_SA_POINT__REF));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1(), semanticObject.eGet(RoomPackage.Literals.REF_SA_POINT__REF, false));
+		feeder.accept(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1(), semanticObject.getRef());
 		feeder.finish();
 	}
 	
@@ -852,7 +852,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.RELAY_SA_POINT__RELAY));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1(), semanticObject.eGet(RoomPackage.Literals.RELAY_SA_POINT__RELAY, false));
+		feeder.accept(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1(), semanticObject.getRelay());
 		feeder.finish();
 	}
 	
@@ -902,7 +902,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
 		feeder.accept(grammarAccess.getSAPAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
-		feeder.accept(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.eGet(RoomPackage.Literals.SAP__PROTOCOL, false));
+		feeder.accept(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.getProtocol());
 		feeder.finish();
 	}
 	
@@ -925,7 +925,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
 		feeder.accept(grammarAccess.getSPPAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
-		feeder.accept(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.eGet(RoomPackage.Literals.SPP__PROTOCOL, false));
+		feeder.accept(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.getProtocol());
 		feeder.finish();
 	}
 	
@@ -945,8 +945,8 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.SP_POINT__SERVICE));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1(), semanticObject.eGet(RoomPackage.Literals.SP_POINT__REF, false));
-		feeder.accept(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1(), semanticObject.eGet(RoomPackage.Literals.SP_POINT__SERVICE, false));
+		feeder.accept(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1(), semanticObject.getRef());
+		feeder.accept(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1(), semanticObject.getService());
 		feeder.finish();
 	}
 	
@@ -964,7 +964,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RoomPackage.Literals.SERVICE_IMPLEMENTATION__SPP));
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
-		feeder.accept(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1(), semanticObject.eGet(RoomPackage.Literals.SERVICE_IMPLEMENTATION__SPP, false));
+		feeder.accept(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1(), semanticObject.getSpp());
 		feeder.finish();
 	}
 	
@@ -1005,7 +1005,7 @@ public class RoomSemanticSequencer extends FSMSemanticSequencer {
 		}
 		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
 		feeder.accept(grammarAccess.getSubProtocolAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
-		feeder.accept(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.eGet(RoomPackage.Literals.SUB_PROTOCOL__PROTOCOL, false));
+		feeder.accept(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1(), semanticObject.getProtocol());
 		feeder.finish();
 	}
 	
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..ec2f36a0d 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,25 +226,28 @@ 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; }
 	}
 
@@ -257,25 +260,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 +290,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 +313,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 +350,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 +440,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 +518,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 +560,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 +641,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 +775,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; }
 	}
 
@@ -918,7 +941,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//':'
 		public Keyword getColonKeyword_6_0() { return cColonKeyword_6_0; }
 
-		//'void' | returnType=RefableType
+		//('void' | returnType=RefableType)
 		public Alternatives getAlternatives_6_1() { return cAlternatives_6_1; }
 
 		//'void'
@@ -1031,7 +1054,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//':'
 		public Keyword getColonKeyword_5_0_0() { return cColonKeyword_5_0_0; }
 
-		//'void' | returnType=RefableType
+		//('void' | returnType=RefableType)
 		public Alternatives getAlternatives_5_0_1() { return cAlternatives_5_0_1; }
 
 		//'void'
@@ -1049,25 +1072,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 +1104,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 +1136,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 +1206,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
@@ -1586,16 +1622,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 +1647,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 +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/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 +1720,13 @@ 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'
+		//// **************************************************************
+		//// actor class
+		//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; }
 	}
 
@@ -1802,7 +1844,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//structors+=ClassStructor)* stateMachine=StateMachine? '}')? '}'
 		public Group getGroup() { return cGroup; }
 
-		//abstract?='abstract'? & commType=ComponentCommunicationType?
+		//(abstract?='abstract'? & commType=ComponentCommunicationType?)
 		public UnorderedGroup getUnorderedGroup_0() { return cUnorderedGroup_0; }
 
 		//abstract?='abstract'?
@@ -2051,19 +2093,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 +2129,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 +2193,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 +2227,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 +2267,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 +2305,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 +2348,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 +2413,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 +2789,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 +2809,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 +2852,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 +2909,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 +2941,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 +2963,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 +2993,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 +3026,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; }
 
 		//'.'
@@ -3082,7 +3148,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//// the following is a data type rule (accompanied by a value converter) and must not be a terminal rule
 		//// (because then the lexer already would find this in places where it is not expected, e.g. in an Attribute)
 		//MULTIPLICITY ecore::EInt:
-		//	'[' ('*' | INT) ']';
+		//	'[' ('*' | INT) ']'
 		@Override public ParserRule getRule() { return rule; }
 
 		//'[' ('*' | INT) ']'
@@ -3091,7 +3157,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 		//'['
 		public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; }
 
-		//'*' | INT
+		//('*' | INT)
 		public Alternatives getAlternatives_1() { return cAlternatives_1; }
 
 		//'*'
@@ -3309,19 +3375,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; }
 	}
 	
@@ -4109,7 +4175,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	//// the following is a data type rule (accompanied by a value converter) and must not be a terminal rule
 	//// (because then the lexer already would find this in places where it is not expected, e.g. in an Attribute)
 	//MULTIPLICITY ecore::EInt:
-	//	'[' ('*' | INT) ']';
+	//	'[' ('*' | INT) ']'
 	public MULTIPLICITYElements getMULTIPLICITYAccess() {
 		return pMULTIPLICITY;
 	}
@@ -4165,10 +4231,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//enum ComponentCommunicationType:
-	//	EVENT_DRIVEN='eventdriven' |
-	//	DATA_DRIVEN='datadriven' |
-	//	ASYNCHRONOUS='async' |
-	//	SYNCHRONOUS='sync';
+	//	EVENT_DRIVEN='eventdriven' | DATA_DRIVEN='datadriven' | ASYNCHRONOUS='async' | SYNCHRONOUS='sync';
 	public FSMGrammarAccess.ComponentCommunicationTypeElements getComponentCommunicationTypeAccess() {
 		return gaFSM.getComponentCommunicationTypeAccess();
 	}
@@ -4178,10 +4241,10 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// state machine
-	////
-	//// the building blocks of a state machine: nodes and items
-	//StateGraphNode:
+	// // state machine
+	// //
+	// // the building blocks of a state machine: nodes and items
+	// StateGraphNode:
 	//	State | ChoicePoint | TrPoint;
 	public FSMGrammarAccess.StateGraphNodeElements getStateGraphNodeAccess() {
 		return gaFSM.getStateGraphNodeAccess();
@@ -4192,7 +4255,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//StateGraphItem:
-	//	StateGraphNode | Transition;
+	//	StateGraphNode | TransitionBase;
 	public FSMGrammarAccess.StateGraphItemElements getStateGraphItemAccess() {
 		return gaFSM.getStateGraphItemAccess();
 	}
@@ -4202,11 +4265,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// state graph and state machine are two rules for the same model class
-	//StateGraph:
-	//	{StateGraph}
-	//	'{' (states+=State | trPoints+=TrPoint | chPoints+=ChoicePoint | transitions+=Transition |
-	//	refinedTransitions+=RefinedTransition)*
-	//	'}';
+	// StateGraph:
+	//	{StateGraph} '{' (states+=State | trPoints+=TrPoint | chPoints+=ChoicePoint | transitions+=Transition |
+	//	refinedTransitions+=RefinedTransition)* '}';
 	public FSMGrammarAccess.StateGraphElements getStateGraphAccess() {
 		return gaFSM.getStateGraphAccess();
 	}
@@ -4216,10 +4277,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//StateMachine StateGraph:
-	//	{StateGraph}
-	//	'StateMachine' '{' (states+=State | trPoints+=TrPoint | chPoints+=ChoicePoint | transitions+=Transition |
-	//	refinedTransitions+=RefinedTransition)*
-	//	'}';
+	//	{StateGraph} 'StateMachine' '{' (states+=State | trPoints+=TrPoint | chPoints+=ChoicePoint | transitions+=Transition
+	//	| refinedTransitions+=RefinedTransition)* '}'
 	public FSMGrammarAccess.StateMachineElements getStateMachineAccess() {
 		return gaFSM.getStateMachineAccess();
 	}
@@ -4229,9 +4288,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// states
-	////
-	//State:
+	// // states
+	// //
+	// State:
 	//	SimpleState | RefinedState;
 	public FSMGrammarAccess.StateElements getStateAccess() {
 		return gaFSM.getStateAccess();
@@ -4243,8 +4302,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 
 	//SimpleState:
 	//	'State' name=ID docu=Documentation? ('{' ('entry' entryCode=DetailCode)? ('exit' exitCode=DetailCode)? ('do'
-	//	doCode=DetailCode)? ('subgraph' subgraph=StateGraph)?
-	//	'}')?;
+	//	doCode=DetailCode)? ('subgraph' subgraph=StateGraph)? '}')?;
 	public FSMGrammarAccess.SimpleStateElements getSimpleStateAccess() {
 		return gaFSM.getSimpleStateAccess();
 	}
@@ -4255,8 +4313,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 
 	//RefinedState:
 	//	'RefinedState' target=[State|FQN] docu=Documentation? '{' ('entry' entryCode=DetailCode)? ('exit'
-	//	exitCode=DetailCode)? ('do' doCode=DetailCode)? ('subgraph' subgraph=StateGraph)?
-	//	'}';
+	//	exitCode=DetailCode)? ('do' doCode=DetailCode)? ('subgraph' subgraph=StateGraph)? '}';
 	public FSMGrammarAccess.RefinedStateElements getRefinedStateAccess() {
 		return gaFSM.getRefinedStateAccess();
 	}
@@ -4266,7 +4323,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// the detail level (or target language) code
-	//// the used flag might be used when overriding in derived grammars
+	// // the used flag might be used when overriding in derived grammars
+	//
 	//DetailCode:
 	//	{DetailCode} lines+=CC_STRING? | used?='{' lines+=STRING* '}';
 	public FSMGrammarAccess.DetailCodeElements getDetailCodeAccess() {
@@ -4278,9 +4336,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// transition points
-	////
-	//TrPoint:
+	// // transition points
+	// //
+	// TrPoint:
 	//	TransitionPoint | EntryPoint | ExitPoint;
 	public FSMGrammarAccess.TrPointElements getTrPointAccess() {
 		return gaFSM.getTrPointAccess();
@@ -4321,9 +4379,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// choice point
-	////
-	//ChoicePoint:
+	// // choice point
+	// //
+	// ChoicePoint:
 	//	'ChoicePoint' name=ID docu=Documentation?;
 	public FSMGrammarAccess.ChoicePointElements getChoicePointAccess() {
 		return gaFSM.getChoicePointAccess();
@@ -4334,9 +4392,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// transitions
-	////
-	//TransitionBase:
+	// // transitions
+	// //
+	// TransitionBase:
 	//	Transition | RefinedTransition;
 	public FSMGrammarAccess.TransitionBaseElements getTransitionBaseAccess() {
 		return gaFSM.getTransitionBaseAccess();
@@ -4377,8 +4435,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//InitialTransition:
-	//	'Transition' name=ID? ':' 'initial' '->' to=TransitionTerminal
-	//	docu=Documentation? ('{' ('action' action=DetailCode)?
+	//	'Transition' name=ID? ':' 'initial' '->' to=TransitionTerminal docu=Documentation? ('{' ('action' action=DetailCode)?
 	//	'}')?;
 	public FSMGrammarAccess.InitialTransitionElements getInitialTransitionAccess() {
 		return gaFSM.getInitialTransitionAccess();
@@ -4389,9 +4446,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//ContinuationTransition:
-	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal
-	//	docu=Documentation? ('{' ('action' action=DetailCode)?
-	//	'}')?;
+	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal docu=Documentation? ('{' ('action'
+	//	action=DetailCode)? '}')?;
 	public FSMGrammarAccess.ContinuationTransitionElements getContinuationTransitionAccess() {
 		return gaFSM.getContinuationTransitionAccess();
 	}
@@ -4401,13 +4457,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//TriggeredTransition:
-	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal
-	//	docu=Documentation?
-	//	'{'
-	//	'triggers' '{'
-	//	triggers+=Trigger ('or' triggers+=Trigger)*
-	//	'}' ('action' action=DetailCode)?
-	//	'}';
+	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal docu=Documentation? '{' 'triggers' '{'
+	//	triggers+=Trigger ('or' triggers+=Trigger)* '}' ('action' action=DetailCode)? '}';
 	public FSMGrammarAccess.TriggeredTransitionElements getTriggeredTransitionAccess() {
 		return gaFSM.getTriggeredTransitionAccess();
 	}
@@ -4417,11 +4468,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//GuardedTransition:
-	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal
-	//	docu=Documentation?
-	//	'{'
-	//	'guard' guard=DetailCode ('action' action=DetailCode)?
-	//	'}';
+	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal docu=Documentation? '{' 'guard'
+	//	guard=DetailCode ('action' action=DetailCode)? '}';
 	public FSMGrammarAccess.GuardedTransitionElements getGuardedTransitionAccess() {
 		return gaFSM.getGuardedTransitionAccess();
 	}
@@ -4431,11 +4479,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//CPBranchTransition:
-	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal
-	//	docu=Documentation?
-	//	'{'
-	//	'cond' condition=DetailCode ('action' action=DetailCode)?
-	//	'}';
+	//	'Transition' name=ID? ':' from=TransitionTerminal '->' to=TransitionTerminal docu=Documentation? '{' 'cond'
+	//	condition=DetailCode ('action' action=DetailCode)? '}';
 	public FSMGrammarAccess.CPBranchTransitionElements getCPBranchTransitionAccess() {
 		return gaFSM.getCPBranchTransitionAccess();
 	}
@@ -4445,11 +4490,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//// by validation RefinedTransition can only be contained in the top level state graph
-	//RefinedTransition:
-	//	'RefinedTransition' target=[Transition|FQN] docu=Documentation?
-	//	'{'
-	//	'action' action=DetailCode
-	//	'}';
+	// RefinedTransition:
+	//	'RefinedTransition' target=[Transition|FQN] docu=Documentation? '{' 'action' action=DetailCode '}';
 	public FSMGrammarAccess.RefinedTransitionElements getRefinedTransitionAccess() {
 		return gaFSM.getRefinedTransitionAccess();
 	}
@@ -4459,9 +4501,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// transition terminals: start and end points of transitions
-	////
-	//TransitionTerminal:
+	// // transition terminals: start and end points of transitions
+	// //
+	// TransitionTerminal:
 	//	StateTerminal | TrPointTerminal | SubStateTrPointTerminal | ChoicepointTerminal;
 	public FSMGrammarAccess.TransitionTerminalElements getTransitionTerminalAccess() {
 		return gaFSM.getTransitionTerminalAccess();
@@ -4512,11 +4554,10 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// transition triggers
-	////
-	//Trigger:
-	//	'<' msgFromIfPairs+=MessageFromIf ('|' msgFromIfPairs+=MessageFromIf)*
-	//	guard=Guard? '>';
+	// // transition triggers
+	// //
+	// Trigger:
+	//	'<' msgFromIfPairs+=MessageFromIf ('|' msgFromIfPairs+=MessageFromIf)* guard=Guard? '>';
 	public FSMGrammarAccess.TriggerElements getTriggerAccess() {
 		return gaFSM.getTriggerAccess();
 	}
@@ -4526,9 +4567,9 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// pairs of (message, interface) are triggering events
-	////
-	//MessageFromIf:
+	// // pairs of (message, interface) are triggering events
+	// //
+	// MessageFromIf:
 	//	message=[ecore::EObject] ':' from=[AbstractInterfaceItem];
 	public FSMGrammarAccess.MessageFromIfElements getMessageFromIfAccess() {
 		return gaFSM.getMessageFromIfAccess();
@@ -4549,13 +4590,10 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	////
-	//// semantics for state machine validation
-	////
-	//ProtocolSemantics:
-	//	{ProtocolSemantics}
-	//	'semantics' '{'
-	//	rules+=SemanticsRule*
-	//	'}';
+	// // semantics for state machine validation
+	// //
+	// ProtocolSemantics:
+	//	{ProtocolSemantics} 'semantics' '{' rules+=SemanticsRule* '}';
 	public FSMGrammarAccess.ProtocolSemanticsElements getProtocolSemanticsAccess() {
 		return gaFSM.getProtocolSemanticsAccess();
 	}
@@ -4575,8 +4613,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//InSemanticsRule:
-	//	'in' ':' msg=[ecore::EObject] ('->' (followUps+=SemanticsRule
-	//	| '(' followUps+=SemanticsRule (',' followUps+=SemanticsRule)+ ')'))?;
+	//	'in' ':' msg=[ecore::EObject] ('->' (followUps+=SemanticsRule | '(' followUps+=SemanticsRule (','
+	//	followUps+=SemanticsRule)+ ')'))?;
 	public FSMGrammarAccess.InSemanticsRuleElements getInSemanticsRuleAccess() {
 		return gaFSM.getInSemanticsRuleAccess();
 	}
@@ -4586,8 +4624,8 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//OutSemanticsRule:
-	//	'out' ':' msg=[ecore::EObject] ('->' (followUps+=SemanticsRule
-	//	| '(' followUps+=SemanticsRule (',' followUps+=SemanticsRule)+ ')'))?;
+	//	'out' ':' msg=[ecore::EObject] ('->' (followUps+=SemanticsRule | '(' followUps+=SemanticsRule (','
+	//	followUps+=SemanticsRule)+ ')'))?;
 	public FSMGrammarAccess.OutSemanticsRuleElements getOutSemanticsRuleAccess() {
 		return gaFSM.getOutSemanticsRuleAccess();
 	}
@@ -4719,7 +4757,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	//// **************************************************************
 	//// Time Rule
 	//TIME ecore::ELong:
-	//	INT 's' | INT 'ms' | INT 'us' | INT 'ns';
+	//	INT 's' | INT 'ms' | INT 'us' | INT 'ns'
 	public BaseGrammarAccess.TIMEElements getTIMEAccess() {
 		return gaBase.getTIMEAccess();
 	}
@@ -4813,7 +4851,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//Integer ecore::ELong:
-	//	('+' | '-')? INT | HEX;
+	//	('+' | '-')? INT | HEX
 	public BaseGrammarAccess.IntegerElements getIntegerAccess() {
 		return gaBase.getIntegerAccess();
 	}
@@ -4823,7 +4861,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	}
 
 	//Real ecore::EDouble:
-	//	Decimal | DecimalExp;
+	//	Decimal | DecimalExp
 	public BaseGrammarAccess.RealElements getRealAccess() {
 		return gaBase.getRealAccess();
 	}
@@ -4898,7 +4936,7 @@ public class RoomGrammarAccess extends AbstractGrammarElementFinder {
 	} 
 
 	//terminal ML_COMMENT:
-	//	'/*'->'*/';
+	//	'/ *'->'* /';
 	public TerminalRule getML_COMMENTRule() {
 		return gaTerminals.getML_COMMENTRule();
 	} 
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/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..082bb6797
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room/src/org/eclipse/etrice/core/room/util/CommonDataCalculator.xtend
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * 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
+	
+	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 as Message).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) {
+					val vd = RoomFactory.eINSTANCE.createVarDecl
+					vd.name = "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 cf6f2a6b5..a43cae7b1 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
@@ -647,9 +647,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());
+			}
 		}
 	}
 
diff --git a/plugins/org.eclipse.etrice.core.room/xtend-gen/org/eclipse/etrice/core/room/util/CommonDataCalculator.java b/plugins/org.eclipse.etrice.core.room/xtend-gen/org/eclipse/etrice/core/room/util/CommonDataCalculator.java
new file mode 100644
index 000000000..54d284670
--- /dev/null
+++ b/plugins/org.eclipse.etrice.core.room/xtend-gen/org/eclipse/etrice/core/room/util/CommonDataCalculator.java
@@ -0,0 +1,108 @@
+/**
+ * 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 com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.fsm.fSM.Trigger;
+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.DataType;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.RefableType;
+import org.eclipse.etrice.core.room.RoomFactory;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@SuppressWarnings("all")
+public class CommonDataCalculator implements ICommonDataCalculator {
+  private RoomHelpers roomHelpers = new RoomHelpers();
+  
+  @Override
+  public EObject calculateCommonData(final Link l) {
+    boolean _isIfitemTriggered = l.isIfitemTriggered();
+    boolean _not = (!_isIfitemTriggered);
+    if (_not) {
+      return null;
+    } else {
+      final Function1<Link, TransitionBase> _function = (Link it) -> {
+        return CommonDataCalculator.realTransition(it.getTransition());
+      };
+      Iterable<TriggeredTransition> transitions = Iterables.<TriggeredTransition>filter(ListExtensions.<Link, TransitionBase>map(l.getChainHeads(), _function), TriggeredTransition.class);
+      final Function1<TriggeredTransition, EList<Trigger>> _function_1 = (TriggeredTransition it) -> {
+        return it.getTriggers();
+      };
+      final Iterable<Trigger> triggers = Iterables.<Trigger>concat(IterableExtensions.<TriggeredTransition, EList<Trigger>>map(transitions, _function_1));
+      final Function1<Trigger, EList<MessageFromIf>> _function_2 = (Trigger it) -> {
+        return it.getMsgFromIfPairs();
+      };
+      final Function1<MessageFromIf, VarDecl> _function_3 = (MessageFromIf it) -> {
+        EObject _message = it.getMessage();
+        return ((Message) _message).getData();
+      };
+      final Iterable<VarDecl> varDeclarations = IterableExtensions.<MessageFromIf, VarDecl>map(Iterables.<MessageFromIf>concat(IterableExtensions.<Trigger, EList<MessageFromIf>>map(triggers, _function_2)), _function_3);
+      final Function1<VarDecl, DataType> _function_4 = (VarDecl it) -> {
+        RefableType _refType = null;
+        if (it!=null) {
+          _refType=it.getRefType();
+        }
+        DataType _type = null;
+        if (_refType!=null) {
+          _type=_refType.getType();
+        }
+        return _type;
+      };
+      final Set<DataType> allData = IterableExtensions.<DataType>toSet(IterableExtensions.<VarDecl, DataType>map(varDeclarations, _function_4));
+      int _size = allData.size();
+      boolean _equals = (_size == 1);
+      if (_equals) {
+        return IterableExtensions.<VarDecl>head(varDeclarations);
+      } else {
+        final Function1<VarDecl, RefableType> _function_5 = (VarDecl it) -> {
+          RefableType _refType = null;
+          if (it!=null) {
+            _refType=it.getRefType();
+          }
+          return _refType;
+        };
+        final List<RefableType> types = IterableExtensions.<RefableType>toList(IterableExtensions.<VarDecl, RefableType>map(varDeclarations, _function_5));
+        final RefableType rt = this.roomHelpers.getLastCommonSuperType(types);
+        boolean _notEquals = (!Objects.equal(rt, null));
+        if (_notEquals) {
+          final VarDecl vd = RoomFactory.eINSTANCE.createVarDecl();
+          vd.setName("data");
+          vd.setRefType(rt);
+          return vd;
+        }
+      }
+    }
+    return null;
+  }
+  
+  private static TransitionBase realTransition(final TransitionBase t) {
+    TransitionBase tr = t;
+    while ((tr instanceof RefinedTransition)) {
+      tr = ((RefinedTransition)tr).getTarget();
+    }
+    return tr;
+  }
+}
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..ccde575e7 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»
@@ -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..f13bc4f7c 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.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 {
 	        ""
@@ -341,10 +340,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);
 	}
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..f9124852e 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 {
 
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..584852e05 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;
 
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..923f15830 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
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..5657c0e0e 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 {
@@ -28,7 +31,7 @@ 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
+		val historySize = xpac.graphContainer.graph.allStateNodes.filter[!inherited].size - xpac.graphContainer.graph.allStateNodes.filter[isLeaf].size + 2
 		'''
 			/* constant for state machine data */
 			#define «ac.name.toUpperCase»_HISTORY_SIZE «historySize»
@@ -60,9 +63,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 */
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ActorClassGen.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ActorClassGen.java
new file mode 100644
index 000000000..8e8605f0e
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ActorClassGen.java
@@ -0,0 +1,1218 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (changed for C code generator)
+ */
+package org.eclipse.etrice.generator.c.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+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.FsmGenExtensions;
+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.CommunicationType;
+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.GeneralProtocolClass;
+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.PortOperation;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.RoomClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SAP;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.c.Main;
+import org.eclipse.etrice.generator.c.gen.CExtensions;
+import org.eclipse.etrice.generator.c.gen.StateMachineGen;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.generic.GenericActorClassGenerator;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ActorClassGen extends GenericActorClassGenerator {
+  @Inject
+  @Extension
+  protected RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  protected CExtensions _cExtensions;
+  
+  @Inject
+  @Extension
+  protected ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  protected StateMachineGen _stateMachineGen;
+  
+  @Inject
+  protected ILanguageExtension langExt;
+  
+  @Inject
+  protected IGeneratorFileIo fileIO;
+  
+  @Inject
+  protected ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    final Function1<ActorClass, ExpandedActorClass> _function = (ActorClass it) -> {
+      return root.getExpandedActorClass(it);
+    };
+    List<ExpandedActorClass> _map = ListExtensions.<ActorClass, ExpandedActorClass>map(root.getActorClasses(), _function);
+    for (final ExpandedActorClass xpac : _map) {
+      {
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(xpac.getActorClass());
+        String _path = this._roomExtensions.getPath(xpac.getActorClass());
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(xpac.getActorClass());
+        String _path_1 = this._roomExtensions.getPath(xpac.getActorClass());
+        final String infopath = (_generationInfoPath + _path_1);
+        String file = this._cExtensions.getCHeaderFileName(xpac.getActorClass());
+        this.fileIO.generateFile("generating ActorClass header", path, infopath, file, this.generateHeaderFile(root, xpac));
+        file = this._cExtensions.getCUtilsFileName(xpac.getActorClass());
+        this.fileIO.generateFile("generating ActorClass utils", path, infopath, file, this.generateUtilsFile(root, xpac));
+        boolean _isBehaviorAnnotationPresent = this._roomHelpers.isBehaviorAnnotationPresent(xpac.getActorClass(), "BehaviorManual");
+        if (_isBehaviorAnnotationPresent) {
+          String _name = xpac.getActorClass().getName();
+          String _plus = ("omitting ActorClass source for \'" + _name);
+          String _plus_1 = (_plus + "\' since @BehaviorManual is specified");
+          this.logger.logInfo(_plus_1);
+        } else {
+          file = this._cExtensions.getCSourceFileName(xpac.getActorClass());
+          this.fileIO.generateFile("generating ActorClass source", path, infopath, file, this.generateSourceFile(root, xpac));
+        }
+      }
+    }
+  }
+  
+  protected CharSequence generateHeaderFile(final Root root, final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      final Function1<Port, Boolean> _function = (Port p) -> {
+        GeneralProtocolClass _protocol = p.getProtocol();
+        CommunicationType _commType = ((ProtocolClass) _protocol).getCommType();
+        return Boolean.valueOf(Objects.equal(_commType, CommunicationType.EVENT_DRIVEN));
+      };
+      final Iterable<Port> eventPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function);
+      final Function1<Port, Boolean> _function_1 = (Port p) -> {
+        return Boolean.valueOf((Objects.equal(((ProtocolClass) p.getProtocol()).getCommType(), CommunicationType.DATA_DRIVEN) && p.isConjugated()));
+      };
+      final Iterable<Port> sendPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function_1);
+      final Function1<Port, Boolean> _function_2 = (Port p) -> {
+        return Boolean.valueOf((Objects.equal(((ProtocolClass) p.getProtocol()).getCommType(), CommunicationType.DATA_DRIVEN) && (!p.isConjugated())));
+      };
+      final Iterable<Port> recvPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function_2);
+      ComponentCommunicationType _commType = ac.getCommType();
+      final boolean dataDriven = Objects.equal(_commType, ComponentCommunicationType.DATA_DRIVEN);
+      ComponentCommunicationType _commType_1 = ac.getCommType();
+      final boolean async = Objects.equal(_commType_1, ComponentCommunicationType.ASYNCHRONOUS);
+      final boolean hasConstData = ((!(((IterableExtensions.isEmpty(eventPorts) && IterableExtensions.isEmpty(recvPorts)) && this._roomHelpers.getAllSAPs(ac).isEmpty()) && this._roomHelpers.getAllServiceImplementations(ac).isEmpty())) || Main.getSettings().isGenerateMSCInstrumentation());
+      final boolean isEmptyStateGraph = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+      final boolean hasVarData = (!(((IterableExtensions.isEmpty(sendPorts) && this._roomHelpers.getAllAttributes(ac).isEmpty()) && isEmptyStateGraph) && (!hasConstData)));
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Header File of ActorClass ");
+      String _name = ac.getName();
+      _builder.append(_name, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(ac);
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"etDatatypes.h\"");
+      _builder.newLine();
+      _builder.append("#include \"messaging/etMessage.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* include all referenced room classes */");
+      _builder.newLine();
+      {
+        EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(ac);
+        EList<EnumerationType> _referencedEnumClasses = root.getReferencedEnumClasses(ac);
+        Iterable<DataType> _plus = Iterables.<DataType>concat(_referencedDataClasses, _referencedEnumClasses);
+        EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(ac);
+        final Function1<RoomClass, String> _function_3 = (RoomClass it) -> {
+          return it.getName();
+        };
+        List<RoomClass> _sortBy = IterableExtensions.<RoomClass, String>sortBy(Iterables.<RoomClass>concat(_plus, _referencedProtocolClasses), _function_3);
+        for(final RoomClass rc : _sortBy) {
+          _builder.append("#include ");
+          String _includePath = this._cExtensions.getIncludePath(rc);
+          _builder.append(_includePath);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(ac, 1, true);
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("typedef struct ");
+      String _name_1 = ac.getName();
+      _builder.append(_name_1);
+      _builder.append(" ");
+      String _name_2 = ac.getName();
+      _builder.append(_name_2);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/* const part of ActorClass (ROM) */");
+      _builder.newLine();
+      {
+        if (hasConstData) {
+          _builder.append("typedef struct ");
+          String _name_3 = ac.getName();
+          _builder.append(_name_3);
+          _builder.append("_const {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation) {
+              _builder.append("\t");
+              _builder.append("const char* instName;");
+              _builder.newLine();
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("/* simple ports */");
+          _builder.newLine();
+          {
+            for(final Port ep : eventPorts) {
+              {
+                int _multiplicity = ep.getMultiplicity();
+                boolean _equals = (_multiplicity == 1);
+                if (_equals) {
+                  _builder.append("\t");
+                  _builder.append("const ");
+                  String _portClassName = this._roomExtensions.getPortClassName(ep);
+                  _builder.append(_portClassName, "\t");
+                  _builder.append(" ");
+                  String _name_4 = ep.getName();
+                  _builder.append(_name_4, "\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* data receive ports */");
+          _builder.newLine();
+          {
+            for(final Port ep_1 : recvPorts) {
+              {
+                int _multiplicity_1 = ep_1.getMultiplicity();
+                boolean _equals_1 = (_multiplicity_1 == 1);
+                if (_equals_1) {
+                  _builder.append("\t");
+                  _builder.append("const ");
+                  String _portClassName_1 = this._roomExtensions.getPortClassName(ep_1);
+                  _builder.append(_portClassName_1, "\t");
+                  _builder.append(" ");
+                  String _name_5 = ep_1.getName();
+                  _builder.append(_name_5, "\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* saps */");
+          _builder.newLine();
+          {
+            List<SAP> _allSAPs = this._roomHelpers.getAllSAPs(ac);
+            for(final SAP sap : _allSAPs) {
+              _builder.append("\t");
+              _builder.append("const ");
+              String _portClassName_2 = this._roomExtensions.getPortClassName(sap);
+              _builder.append(_portClassName_2, "\t");
+              _builder.append(" ");
+              String _name_6 = sap.getName();
+              _builder.append(_name_6, "\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* replicated ports */");
+          _builder.newLine();
+          {
+            List<Port> _allEndPorts = this._roomHelpers.getAllEndPorts(ac);
+            for(final Port ep_2 : _allEndPorts) {
+              {
+                int _multiplicity_2 = ep_2.getMultiplicity();
+                boolean _notEquals = (_multiplicity_2 != 1);
+                if (_notEquals) {
+                  _builder.append("\t");
+                  _builder.append("const etReplPort ");
+                  String _name_7 = ep_2.getName();
+                  _builder.append(_name_7, "\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* services */");
+          _builder.newLine();
+          {
+            List<ServiceImplementation> _allServiceImplementations = this._roomHelpers.getAllServiceImplementations(ac);
+            for(final ServiceImplementation svc : _allServiceImplementations) {
+              _builder.append("\t");
+              _builder.append("const etReplPort ");
+              String _name_8 = svc.getSpp().getName();
+              _builder.append(_name_8, "\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("} ");
+          String _name_9 = ac.getName();
+          _builder.append(_name_9);
+          _builder.append("_const;");
+          _builder.newLineIfNotEmpty();
+        } else {
+          _builder.append("/* this actor class has no ports and thus no constant data */");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        if ((!isEmptyStateGraph)) {
+          _builder.newLine();
+          CharSequence _genHeaderConstants = this._stateMachineGen.genHeaderConstants(xpac);
+          _builder.append(_genHeaderConstants);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* variable part of ActorClass (RAM) */");
+      _builder.newLine();
+      {
+        if (hasVarData) {
+          _builder.append("struct ");
+          String _name_10 = ac.getName();
+          _builder.append(_name_10);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          {
+            if (hasConstData) {
+              _builder.append("\t");
+              _builder.append("const ");
+              String _name_11 = ac.getName();
+              _builder.append(_name_11, "\t");
+              _builder.append("_const* const constData;");
+              _builder.newLineIfNotEmpty();
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("/* data send ports */");
+          _builder.newLine();
+          {
+            for(final Port ep_3 : sendPorts) {
+              {
+                int _multiplicity_3 = ep_3.getMultiplicity();
+                boolean _equals_2 = (_multiplicity_3 == 1);
+                if (_equals_2) {
+                  _builder.append("\t");
+                  String _portClassName_3 = this._roomExtensions.getPortClassName(ep_3);
+                  _builder.append(_portClassName_3, "\t");
+                  _builder.append(" ");
+                  String _name_12 = ep_3.getName();
+                  _builder.append(_name_12, "\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _attributes = this._procedureHelpers.attributes(this._roomHelpers.getAllAttributes(ac));
+          _builder.append(_attributes, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+          {
+            if ((!isEmptyStateGraph)) {
+              _builder.newLine();
+              _builder.append("\t");
+              CharSequence _genDataMembers = this._stateMachineGen.genDataMembers(xpac);
+              _builder.append(_genDataMembers, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("};");
+          _builder.newLine();
+        } else {
+          _builder.append("struct ");
+          String _name_13 = ac.getName();
+          _builder.append(_name_13);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("/* This actor class has no data at all.");
+          _builder.newLine();
+          _builder.append("\t   ");
+          _builder.append("But the private actor instance data is passed to all life cycle functions.");
+          _builder.newLine();
+          _builder.append("\t   ");
+          _builder.append("By introducing the dummy data we keep this case simple");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("*/");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("int dummy;");
+          _builder.newLine();
+          _builder.append("};");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_14 = ac.getName();
+      _builder.append(_name_14);
+      _builder.append("_init(");
+      String _name_15 = ac.getName();
+      _builder.append(_name_15);
+      _builder.append("* self);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_16 = ac.getName();
+      _builder.append(_name_16);
+      _builder.append("_receiveMessage(void* self, const void* ifitem, const etMessage* msg);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if ((dataDriven || async)) {
+          _builder.append("void ");
+          String _name_17 = ac.getName();
+          _builder.append(_name_17);
+          _builder.append("_execute(");
+          String _name_18 = ac.getName();
+          _builder.append(_name_18);
+          _builder.append("* self);");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      String _userStructorsDeclaration = this._procedureHelpers.userStructorsDeclaration(ac);
+      _builder.append(_userStructorsDeclaration);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _operationsDeclaration = this._procedureHelpers.operationsDeclaration(this._roomHelpers.getLatestOperations(ac), ac.getName());
+      _builder.append(_operationsDeclaration);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(ac, 2, true);
+      _builder.append(_userCode_1);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(ac);
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence generateUtilsFile(final Root root, final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      final Function1<Port, Boolean> _function = (Port p) -> {
+        GeneralProtocolClass _protocol = p.getProtocol();
+        CommunicationType _commType = ((ProtocolClass) _protocol).getCommType();
+        return Boolean.valueOf(Objects.equal(_commType, CommunicationType.EVENT_DRIVEN));
+      };
+      final Iterable<Port> eventPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function);
+      final Function1<Port, Boolean> _function_1 = (Port it) -> {
+        int _multiplicity = it.getMultiplicity();
+        return Boolean.valueOf((_multiplicity != 1));
+      };
+      final Iterable<Port> replEventPorts = IterableExtensions.<Port>filter(eventPorts, _function_1);
+      final Function1<Port, Boolean> _function_2 = (Port p) -> {
+        return Boolean.valueOf(((Objects.equal(((ProtocolClass) p.getProtocol()).getCommType(), CommunicationType.DATA_DRIVEN) && p.isConjugated()) && (p.getMultiplicity() == 1)));
+      };
+      final Iterable<Port> sendPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function_2);
+      final Function1<Port, Boolean> _function_3 = (Port p) -> {
+        return Boolean.valueOf(((Objects.equal(((ProtocolClass) p.getProtocol()).getCommType(), CommunicationType.DATA_DRIVEN) && (!p.isConjugated())) && (p.getMultiplicity() == 1)));
+      };
+      final Iterable<Port> recvPorts = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function_3);
+      final Function1<InterfaceItem, Boolean> _function_4 = (InterfaceItem p) -> {
+        return Boolean.valueOf(((!Objects.equal(this._roomHelpers.getPortClass(p), null)) && (this._roomHelpers.getPortClass(p).getOperations().size() > 0)));
+      };
+      final Iterable<InterfaceItem> portsWithOperations = IterableExtensions.<InterfaceItem>filter(this._roomHelpers.getAllInterfaceItems(ac), _function_4);
+      EObject _eContainer = ac.eContainer();
+      String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "_");
+      String _plus = (_replaceAll + "_");
+      String _name = ac.getName();
+      String _plus_1 = (_plus + _name);
+      final String filename = (_plus_1 + "_Utils");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Utils File of ActorClass ");
+      String _name_1 = ac.getName();
+      _builder.append(_name_1, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(filename);
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include ");
+      String _includePath = this._cExtensions.getIncludePath(ac);
+      _builder.append(_includePath);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* access macros for ports, operations and attributes");
+      _builder.newLine();
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* simple event ports */");
+      _builder.newLine();
+      {
+        final Function1<Port, Boolean> _function_5 = (Port it) -> {
+          int _multiplicity = it.getMultiplicity();
+          return Boolean.valueOf((_multiplicity == 1));
+        };
+        Iterable<Port> _filter = IterableExtensions.<Port>filter(eventPorts, _function_5);
+        for(final Port ep : _filter) {
+          {
+            List<Message> _outgoing = this._roomHelpers.getOutgoing(ep);
+            for(final Message msg : _outgoing) {
+              String _xifexpression = null;
+              VarDecl _data = msg.getData();
+              boolean _notEquals = (!Objects.equal(_data, null));
+              if (_notEquals) {
+                _xifexpression = "data";
+              } else {
+                _xifexpression = "";
+              }
+              final String data1 = _xifexpression;
+              _builder.newLineIfNotEmpty();
+              String _xifexpression_1 = null;
+              VarDecl _data_1 = msg.getData();
+              boolean _notEquals_1 = (!Objects.equal(_data_1, null));
+              if (_notEquals_1) {
+                _xifexpression_1 = ", data";
+              } else {
+                _xifexpression_1 = "";
+              }
+              final String data2 = _xifexpression_1;
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_2 = ep.getName();
+              _builder.append(_name_2);
+              _builder.append("_");
+              String _name_3 = msg.getName();
+              _builder.append(_name_3);
+              _builder.append("(");
+              _builder.append(data1);
+              _builder.append(") ");
+              String _portClassName = this._roomExtensions.getPortClassName(ep);
+              _builder.append(_portClassName);
+              _builder.append("_");
+              String _name_4 = msg.getName();
+              _builder.append(_name_4);
+              _builder.append("(&self->constData->");
+              String _name_5 = ep.getName();
+              _builder.append(_name_5);
+              _builder.append(data2);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* data receive ports */");
+      _builder.newLine();
+      {
+        for(final Port ep_1 : recvPorts) {
+          {
+            List<Message> _incoming = this._roomHelpers.getIncoming(ep_1);
+            for(final Message msg_1 : _incoming) {
+              _builder.append("#define ");
+              String _name_6 = ep_1.getName();
+              _builder.append(_name_6);
+              _builder.append("_");
+              String _name_7 = msg_1.getName();
+              _builder.append(_name_7);
+              _builder.append(" ");
+              String _portClassName_1 = this._roomExtensions.getPortClassName(ep_1);
+              _builder.append(_portClassName_1);
+              _builder.append("_");
+              String _name_8 = msg_1.getName();
+              _builder.append(_name_8);
+              _builder.append("_get(&self->constData->");
+              String _name_9 = ep_1.getName();
+              _builder.append(_name_9);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* data send ports */");
+      _builder.newLine();
+      {
+        for(final Port ep_2 : sendPorts) {
+          {
+            List<Message> _outgoing_1 = this._roomHelpers.getOutgoing(ep_2);
+            for(final Message msg_2 : _outgoing_1) {
+              String _xifexpression_2 = null;
+              VarDecl _data_2 = msg_2.getData();
+              boolean _notEquals_2 = (!Objects.equal(_data_2, null));
+              if (_notEquals_2) {
+                _xifexpression_2 = "data";
+              } else {
+                _xifexpression_2 = "";
+              }
+              final String data1_1 = _xifexpression_2;
+              _builder.newLineIfNotEmpty();
+              String _xifexpression_3 = null;
+              VarDecl _data_3 = msg_2.getData();
+              boolean _notEquals_3 = (!Objects.equal(_data_3, null));
+              if (_notEquals_3) {
+                _xifexpression_3 = ", data";
+              } else {
+                _xifexpression_3 = "";
+              }
+              final String data2_1 = _xifexpression_3;
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_10 = ep_2.getName();
+              _builder.append(_name_10);
+              _builder.append("_");
+              String _name_11 = msg_2.getName();
+              _builder.append(_name_11);
+              _builder.append("(");
+              _builder.append(data1_1);
+              _builder.append(") ");
+              String _portClassName_2 = this._roomExtensions.getPortClassName(ep_2);
+              _builder.append(_portClassName_2);
+              _builder.append("_");
+              String _name_12 = msg_2.getName();
+              _builder.append(_name_12);
+              _builder.append("_set(&self->");
+              String _name_13 = ep_2.getName();
+              _builder.append(_name_13);
+              _builder.append(data2_1);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* saps */");
+      _builder.newLine();
+      {
+        List<SAP> _allSAPs = this._roomHelpers.getAllSAPs(ac);
+        for(final SAP sap : _allSAPs) {
+          {
+            List<Message> _outgoing_2 = this._roomHelpers.getOutgoing(sap);
+            for(final Message msg_3 : _outgoing_2) {
+              String _xifexpression_4 = null;
+              VarDecl _data_4 = msg_3.getData();
+              boolean _notEquals_4 = (!Objects.equal(_data_4, null));
+              if (_notEquals_4) {
+                _xifexpression_4 = "data";
+              } else {
+                _xifexpression_4 = "";
+              }
+              final String data1_2 = _xifexpression_4;
+              _builder.newLineIfNotEmpty();
+              String _xifexpression_5 = null;
+              VarDecl _data_5 = msg_3.getData();
+              boolean _notEquals_5 = (!Objects.equal(_data_5, null));
+              if (_notEquals_5) {
+                _xifexpression_5 = ", data";
+              } else {
+                _xifexpression_5 = "";
+              }
+              final String data2_2 = _xifexpression_5;
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_14 = sap.getName();
+              _builder.append(_name_14);
+              _builder.append("_");
+              String _name_15 = msg_3.getName();
+              _builder.append(_name_15);
+              _builder.append("(");
+              _builder.append(data1_2);
+              _builder.append(") ");
+              String _portClassName_3 = this._roomExtensions.getPortClassName(sap);
+              _builder.append(_portClassName_3);
+              _builder.append("_");
+              String _name_16 = msg_3.getName();
+              _builder.append(_name_16);
+              _builder.append("(&self->constData->");
+              String _name_17 = sap.getName();
+              _builder.append(_name_17);
+              _builder.append(data2_2);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* replicated event ports */");
+      _builder.newLine();
+      {
+        boolean _isEmpty = IterableExtensions.isEmpty(replEventPorts);
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("#define ifitem_index (((etReplSubPort*)ifitem)->index)");
+          _builder.newLine();
+        }
+      }
+      {
+        for(final Port ep_3 : replEventPorts) {
+          {
+            List<Message> _outgoing_3 = this._roomHelpers.getOutgoing(ep_3);
+            for(final Message msg_4 : _outgoing_3) {
+              String _xifexpression_6 = null;
+              VarDecl _data_6 = msg_4.getData();
+              boolean _notEquals_6 = (!Objects.equal(_data_6, null));
+              if (_notEquals_6) {
+                _xifexpression_6 = "data";
+              } else {
+                _xifexpression_6 = "";
+              }
+              final String data1_3 = _xifexpression_6;
+              _builder.newLineIfNotEmpty();
+              String _xifexpression_7 = null;
+              VarDecl _data_7 = msg_4.getData();
+              boolean _notEquals_7 = (!Objects.equal(_data_7, null));
+              if (_notEquals_7) {
+                _xifexpression_7 = ", data";
+              } else {
+                _xifexpression_7 = "";
+              }
+              final String data2_3 = _xifexpression_7;
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_18 = ep_3.getName();
+              _builder.append(_name_18);
+              _builder.append("_");
+              String _name_19 = msg_4.getName();
+              _builder.append(_name_19);
+              _builder.append("_broadcast(");
+              _builder.append(data1_3);
+              _builder.append(") ");
+              String _portClassName_4 = this._roomExtensions.getPortClassName(ep_3);
+              _builder.append(_portClassName_4);
+              _builder.append("_");
+              String _name_20 = msg_4.getName();
+              _builder.append(_name_20);
+              _builder.append("_broadcast(&self->constData->");
+              String _name_21 = ep_3.getName();
+              _builder.append(_name_21);
+              _builder.append(data2_3);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_22 = ep_3.getName();
+              _builder.append(_name_22);
+              _builder.append("_");
+              String _name_23 = msg_4.getName();
+              _builder.append(_name_23);
+              _builder.append("(idx");
+              _builder.append(data2_3);
+              _builder.append(") ");
+              String _portClassName_5 = this._roomExtensions.getPortClassName(ep_3);
+              _builder.append(_portClassName_5);
+              _builder.append("_");
+              String _name_24 = msg_4.getName();
+              _builder.append(_name_24);
+              _builder.append("(&self->constData->");
+              String _name_25 = ep_3.getName();
+              _builder.append(_name_25);
+              _builder.append(", idx");
+              _builder.append(data2_3);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* services */");
+      _builder.newLine();
+      {
+        List<ServiceImplementation> _allServiceImplementations = this._roomHelpers.getAllServiceImplementations(ac);
+        for(final ServiceImplementation svc : _allServiceImplementations) {
+          {
+            List<Message> _outgoing_4 = this._roomHelpers.getOutgoing(svc.getSpp());
+            for(final Message msg_5 : _outgoing_4) {
+              String _xifexpression_8 = null;
+              VarDecl _data_8 = msg_5.getData();
+              boolean _notEquals_8 = (!Objects.equal(_data_8, null));
+              if (_notEquals_8) {
+                _xifexpression_8 = "data";
+              } else {
+                _xifexpression_8 = "";
+              }
+              final String data1_4 = _xifexpression_8;
+              _builder.newLineIfNotEmpty();
+              String _xifexpression_9 = null;
+              VarDecl _data_9 = msg_5.getData();
+              boolean _notEquals_9 = (!Objects.equal(_data_9, null));
+              if (_notEquals_9) {
+                _xifexpression_9 = ", data";
+              } else {
+                _xifexpression_9 = "";
+              }
+              final String data2_4 = _xifexpression_9;
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_26 = svc.getSpp().getName();
+              _builder.append(_name_26);
+              _builder.append("_");
+              String _name_27 = msg_5.getName();
+              _builder.append(_name_27);
+              _builder.append("_broadcast(");
+              _builder.append(data1_4);
+              _builder.append(") ");
+              String _portClassName_6 = this._roomExtensions.getPortClassName(svc.getSpp());
+              _builder.append(_portClassName_6);
+              _builder.append("_");
+              String _name_28 = msg_5.getName();
+              _builder.append(_name_28);
+              _builder.append("_broadcast(&self->constData->");
+              String _name_29 = svc.getSpp().getName();
+              _builder.append(_name_29);
+              _builder.append(data2_4);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_30 = svc.getSpp().getName();
+              _builder.append(_name_30);
+              _builder.append("_");
+              String _name_31 = msg_5.getName();
+              _builder.append(_name_31);
+              _builder.append("(idx");
+              _builder.append(data2_4);
+              _builder.append(") ");
+              String _portClassName_7 = this._roomExtensions.getPortClassName(svc.getSpp());
+              _builder.append(_portClassName_7);
+              _builder.append("_");
+              String _name_32 = msg_5.getName();
+              _builder.append(_name_32);
+              _builder.append("(&self->constData->");
+              String _name_33 = svc.getSpp().getName();
+              _builder.append(_name_33);
+              _builder.append(", idx");
+              _builder.append(data2_4);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* operations */");
+      _builder.newLine();
+      {
+        List<StandardOperation> _latestOperations = this._roomHelpers.getLatestOperations(ac);
+        for(final StandardOperation op : _latestOperations) {
+          final CharSequence args = this.argList(op);
+          _builder.newLineIfNotEmpty();
+          _builder.append("#define ");
+          String _name_34 = op.getName();
+          _builder.append(_name_34);
+          _builder.append("(");
+          _builder.append(args);
+          _builder.append(") ");
+          String _name_35 = ac.getName();
+          _builder.append(_name_35);
+          _builder.append("_");
+          String _name_36 = op.getName();
+          _builder.append(_name_36);
+          _builder.append("(self");
+          {
+            boolean _isEmpty_1 = op.getArguments().isEmpty();
+            boolean _not_1 = (!_isEmpty_1);
+            if (_not_1) {
+              _builder.append(", ");
+              _builder.append(args);
+            }
+          }
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* attributes */");
+      _builder.newLine();
+      {
+        List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(ac);
+        for(final Attribute a : _allAttributes) {
+          _builder.append("#define ");
+          String _name_37 = a.getName();
+          _builder.append(_name_37);
+          _builder.append(" (self->");
+          String _name_38 = a.getName();
+          _builder.append(_name_38);
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* port operations */");
+      _builder.newLine();
+      {
+        for(final InterfaceItem p : portsWithOperations) {
+          {
+            EList<PortOperation> _operations = this._roomHelpers.getPortClass(p).getOperations();
+            for(final PortOperation op_1 : _operations) {
+              final CharSequence args_1 = this.argList(op_1);
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name_39 = p.getName();
+              _builder.append(_name_39);
+              _builder.append("_");
+              String _name_40 = op_1.getName();
+              _builder.append(_name_40);
+              _builder.append("(");
+              _builder.append(args_1);
+              _builder.append(") ");
+              String _portClassName_8 = this._roomExtensions.getPortClassName(p);
+              _builder.append(_portClassName_8);
+              _builder.append("_");
+              String _name_41 = op_1.getName();
+              _builder.append(_name_41);
+              _builder.append("((");
+              String _portClassName_9 = this._roomExtensions.getPortClassName(p);
+              _builder.append(_portClassName_9);
+              _builder.append("*)&self->constData->");
+              String _name_42 = p.getName();
+              _builder.append(_name_42);
+              {
+                boolean _isEmpty_2 = op_1.getArguments().isEmpty();
+                boolean _not_2 = (!_isEmpty_2);
+                if (_not_2) {
+                  _builder.append(", ");
+                  _builder.append(args_1);
+                }
+              }
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(filename);
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence argList(final Operation op) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<VarDecl> _arguments = op.getArguments();
+      boolean _hasElements = false;
+      for(final VarDecl a : _arguments) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(", ", "");
+        }
+        String _name = a.getName();
+        _builder.append(_name);
+      }
+    }
+    return _builder;
+  }
+  
+  protected CharSequence generateSourceFile(final Root root, final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      ComponentCommunicationType _commType = ac.getCommType();
+      final boolean async = Objects.equal(_commType, ComponentCommunicationType.ASYNCHRONOUS);
+      ComponentCommunicationType _commType_1 = ac.getCommType();
+      final boolean eventDriven = Objects.equal(_commType_1, ComponentCommunicationType.EVENT_DRIVEN);
+      ComponentCommunicationType _commType_2 = ac.getCommType();
+      final boolean dataDriven = Objects.equal(_commType_2, ComponentCommunicationType.DATA_DRIVEN);
+      final boolean handleEvents = (async || eventDriven);
+      final boolean isEmptyStateGraph = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Source File of ActorClass ");
+      String _name = ac.getName();
+      _builder.append(_name, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cHeaderFileName = this._cExtensions.getCHeaderFileName(ac);
+      _builder.append(_cHeaderFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"modelbase/etActor.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etMSCLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"etUnit/etUnit.h\"");
+      _builder.newLine();
+      _builder.append("#include \"base/etMemory.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(ac);
+        for(final ProtocolClass pc : _referencedProtocolClasses) {
+          _builder.append("#include ");
+          String _includePath = this._cExtensions.getIncludePath(pc);
+          _builder.append(_includePath);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cUtilsFileName = this._cExtensions.getCUtilsFileName(ac);
+      _builder.append(_cUtilsFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(ac, 3, true);
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/* interface item IDs */");
+      _builder.newLine();
+      String _genInterfaceItemConstants = this.genInterfaceItemConstants(xpac);
+      _builder.append(_genInterfaceItemConstants);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if ((!isEmptyStateGraph)) {
+          CharSequence _genStateMachine = this._stateMachineGen.genStateMachine(xpac.getGraphContainer());
+          _builder.append(_genStateMachine);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_1 = ac.getName();
+      _builder.append(_name_1);
+      _builder.append("_init(");
+      String _name_2 = ac.getName();
+      _builder.append(_name_2);
+      _builder.append("* self){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      String _name_3 = ac.getName();
+      _builder.append(_name_3, "\t");
+      _builder.append("\", \"init\")");
+      _builder.newLineIfNotEmpty();
+      {
+        if ((!isEmptyStateGraph)) {
+          _builder.append("\t");
+          CharSequence _genInitialization = this._stateMachineGen.genInitialization(xpac);
+          _builder.append(_genInitialization, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_4 = ac.getName();
+      _builder.append(_name_4);
+      _builder.append("_receiveMessage(void* self, const void* ifitem, const etMessage* msg){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      String _name_5 = ac.getName();
+      _builder.append(_name_5, "\t");
+      _builder.append("\", \"_receiveMessage\")");
+      _builder.newLineIfNotEmpty();
+      {
+        if ((!isEmptyStateGraph)) {
+          {
+            if (handleEvents) {
+              _builder.append("\t");
+              String _operationScope = this.langExt.operationScope(ac.getName(), false);
+              _builder.append(_operationScope, "\t");
+              _builder.append("receiveEvent(self, (etPort*)ifitem, msg->evtID, (void*)(((char*)msg)+MEM_CEIL(sizeof(etMessage))));");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t");
+              String _operationScope_1 = this.langExt.operationScope(ac.getName(), false);
+              _builder.append(_operationScope_1, "\t");
+              _builder.append("receiveEventInternal(self);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        if ((dataDriven || async)) {
+          _builder.append("void ");
+          String _name_6 = ac.getName();
+          _builder.append(_name_6);
+          _builder.append("_execute(");
+          String _name_7 = ac.getName();
+          _builder.append(_name_7);
+          _builder.append("* self) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+          String _name_8 = ac.getName();
+          _builder.append(_name_8, "\t");
+          _builder.append("\", \"_execute\")");
+          _builder.newLineIfNotEmpty();
+          {
+            if ((!isEmptyStateGraph)) {
+              _builder.newLine();
+              {
+                if (handleEvents) {
+                  _builder.append("\t");
+                  String _operationScope_2 = this.langExt.operationScope(ac.getName(), false);
+                  _builder.append(_operationScope_2, "\t");
+                  _builder.append("receiveEvent(self, NULL, 0, NULL);");
+                  _builder.newLineIfNotEmpty();
+                } else {
+                  _builder.append("\t");
+                  String _operationScope_3 = this.langExt.operationScope(ac.getName(), false);
+                  _builder.append(_operationScope_3, "\t");
+                  _builder.append("receiveEventInternal(self);");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      String _userStructorsImplementation = this._procedureHelpers.userStructorsImplementation(ac);
+      _builder.append(_userStructorsImplementation);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(this._roomHelpers.getLatestOperations(ac), ac.getName());
+      _builder.append(_operationsImplementation);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/CExtensions.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/CExtensions.java
new file mode 100644
index 000000000..23e59b4b8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/CExtensions.java
@@ -0,0 +1,760 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (changed for C code generator)
+ */
+package org.eclipse.etrice.generator.c.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+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.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.room.Message;
+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.fsm.generic.ILanguageExtensionBase;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+@Singleton
+@SuppressWarnings("all")
+public class CExtensions implements ILanguageExtension {
+  @Inject
+  protected IDiagnostician diagnostician;
+  
+  @Inject
+  @Extension
+  protected RoomHelpers _roomHelpers;
+  
+  @Override
+  public String getTypedDataDefinition(final EObject msg) {
+    String _xifexpression = null;
+    if ((msg instanceof Message)) {
+      _xifexpression = this.generateArglistAndTypedData(((Message) msg).getData())[ILanguageExtensionBase.TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal()];
+    } else {
+      _xifexpression = "";
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String accessLevelPrivate() {
+    return "static ";
+  }
+  
+  @Override
+  public String accessLevelProtected() {
+    return "static ";
+  }
+  
+  @Override
+  public String accessLevelPublic() {
+    return "";
+  }
+  
+  @Override
+  public String memberAccess() {
+    return "self->";
+  }
+  
+  @Override
+  public String selfPointer(final String classname, final boolean hasArgs) {
+    String _xifexpression = null;
+    if (hasArgs) {
+      _xifexpression = "* self, ";
+    } else {
+      _xifexpression = "* self";
+    }
+    return (classname + _xifexpression);
+  }
+  
+  @Override
+  public String selfPointer(final boolean hasArgs) {
+    String _xifexpression = null;
+    if (hasArgs) {
+      _xifexpression = "self, ";
+    } else {
+      _xifexpression = "self";
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String scopeSeparator() {
+    return "";
+  }
+  
+  @Override
+  public String operationScope(final String classname, final boolean isDeclaration) {
+    return (classname + "_");
+  }
+  
+  @Override
+  public String memberInDeclaration(final String namespace, final String member) {
+    return ((namespace + "_") + member);
+  }
+  
+  @Override
+  public String memberInUse(final String namespace, final String member) {
+    return ((namespace + "_") + member);
+  }
+  
+  /**
+   * TODO: move specific code elsewhere
+   */
+  public String getCHeaderFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".h");
+  }
+  
+  public String getCSourceFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".c");
+  }
+  
+  public String getCUtilsFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + "_Utils.h");
+  }
+  
+  public String getInstSourceFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + "_Inst.h");
+  }
+  
+  public String getDispSourceFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + "_Disp.h");
+  }
+  
+  public String getCHeaderFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = (_name + "_");
+    String _name_1 = ssi.getName();
+    String _plus_1 = (_plus + _name_1);
+    return (_plus_1 + ".h");
+  }
+  
+  public String getCSourceFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = (_name + "_");
+    String _name_1 = ssi.getName();
+    String _plus_1 = (_plus + _name_1);
+    return (_plus_1 + ".c");
+  }
+  
+  public String getInstSourceFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = (_name + "_");
+    String _name_1 = ssi.getName();
+    String _plus_1 = (_plus + _name_1);
+    return (_plus_1 + "_Inst.h");
+  }
+  
+  public String getDispSourceFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = (_name + "_");
+    String _name_1 = ssi.getName();
+    String _plus_1 = (_plus + _name_1);
+    return (_plus_1 + "_Disp.h");
+  }
+  
+  public CharSequence getIncludeGuardString(final String filename) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("_");
+    String _upperCase = filename.toUpperCase();
+    _builder.append(_upperCase);
+    _builder.append("_H_");
+    return _builder;
+  }
+  
+  public CharSequence generateIncludeGuardBegin(final RoomClass rc) {
+    CharSequence _xblockexpression = null;
+    {
+      EObject _eContainer = rc.eContainer();
+      String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "_");
+      String _plus = (_replaceAll + "_");
+      String _name = rc.getName();
+      final String filename = (_plus + _name);
+      _xblockexpression = this.generateIncludeGuardBegin(filename);
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence generateIncludeGuardEnd(final RoomClass rc) {
+    CharSequence _xblockexpression = null;
+    {
+      EObject _eContainer = rc.eContainer();
+      String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "_");
+      String _plus = (_replaceAll + "_");
+      String _name = rc.getName();
+      final String filename = (_plus + _name);
+      _xblockexpression = this.generateIncludeGuardEnd(filename);
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence generateIncludeGuardBegin(final String filename) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("#ifndef ");
+    CharSequence _includeGuardString = this.getIncludeGuardString(filename);
+    _builder.append(_includeGuardString);
+    _builder.newLineIfNotEmpty();
+    _builder.append("#define ");
+    CharSequence _includeGuardString_1 = this.getIncludeGuardString(filename);
+    _builder.append(_includeGuardString_1);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  public CharSequence generateIncludeGuardEnd(final String filename) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("#endif /* ");
+    CharSequence _includeGuardString = this.getIncludeGuardString(filename);
+    _builder.append(_includeGuardString);
+    _builder.append(" */");
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  @Override
+  public boolean usesInheritance() {
+    return false;
+  }
+  
+  @Override
+  public boolean usesPointers() {
+    return true;
+  }
+  
+  @Override
+  public String genEnumeration(final String name, final List<Pair<String, String>> entries) {
+    String _xblockexpression = null;
+    {
+      boolean _isEmpty = entries.isEmpty();
+      if (_isEmpty) {
+        return "/* empty enum not generated */";
+      }
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("enum ");
+      _builder.append(name);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _hasElements = false;
+        for(final Pair<String, String> entry : entries) {
+          if (!_hasElements) {
+            _hasElements = true;
+          } else {
+            _builder.appendImmediate(",", "\t");
+          }
+          _builder.append("\t");
+          String _first = entry.getFirst();
+          _builder.append(_first, "\t");
+          _builder.append(" = ");
+          String _second = entry.getSecond();
+          _builder.append(_second, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String booleanConstant(final boolean b) {
+    String _xifexpression = null;
+    if (b) {
+      _xifexpression = "ET_TRUE";
+    } else {
+      _xifexpression = "ET_FALSE";
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String pointerLiteral() {
+    return "*";
+  }
+  
+  @Override
+  public String nullPointer() {
+    return "NULL";
+  }
+  
+  @Override
+  public String voidPointer() {
+    return "void*";
+  }
+  
+  @Override
+  public String arrayType(final String type, final int size, final boolean isRef) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(type);
+    {
+      if (isRef) {
+        _builder.append("*");
+      }
+    }
+    _builder.newLineIfNotEmpty();
+    return _builder.toString();
+  }
+  
+  @Override
+  public String arrayDeclaration(final String type, final int size, final boolean isRef, final String name) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(type);
+    {
+      if (isRef) {
+        _builder.append("*");
+      }
+    }
+    _builder.append(" ");
+    _builder.append(name);
+    _builder.append("[");
+    _builder.append(size);
+    _builder.append("]");
+    _builder.newLineIfNotEmpty();
+    return _builder.toString();
+  }
+  
+  @Override
+  public String superCall(final String baseClassName, final String method, final String args) {
+    return "";
+  }
+  
+  @Override
+  public String toValueLiteral(final PrimitiveType type, final String value) {
+    String _switchResult = null;
+    String _targetName = type.getTargetName();
+    boolean _matched = false;
+    if ((type.getTargetName().equals("char") && (value.length() == 1))) {
+      _matched=true;
+      _switchResult = (("\'" + value) + "\'");
+    }
+    if (!_matched) {
+      LiteralType _type = type.getType();
+      boolean _equals = Objects.equal(_type, LiteralType.CHAR);
+      if (_equals) {
+        _matched=true;
+        _switchResult = (("\"" + value) + "\"");
+      }
+    }
+    if (!_matched) {
+      if ((value.contains(",") || value.contains("{"))) {
+        _matched=true;
+        String _xblockexpression = null;
+        {
+          String[] singleValues = value.replace("{", "").replace("}", "").trim().split(",");
+          StringConcatenation _builder = new StringConcatenation();
+          _builder.append("{ ");
+          {
+            boolean _hasElements = false;
+            for(final String v : singleValues) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate(", ", "");
+              }
+              String _valueLiteral = this.toValueLiteral(type, v.trim());
+              _builder.append(_valueLiteral);
+            }
+          }
+          _builder.append(" }");
+          _xblockexpression = _builder.toString();
+        }
+        _switchResult = _xblockexpression;
+      }
+    }
+    if (!_matched) {
+      if (Objects.equal(_targetName, "boolean")) {
+        _matched=true;
+        String _xifexpression = null;
+        boolean _equals_1 = value.equals("true");
+        if (_equals_1) {
+          _xifexpression = "ET_TRUE";
+        } else {
+          _xifexpression = "ET_FALSE";
+        }
+        _switchResult = _xifexpression;
+      }
+    }
+    if (!_matched) {
+      _switchResult = value;
+    }
+    return _switchResult;
+  }
+  
+  @Override
+  public String toEnumLiteral(final EnumerationType type, final String value) {
+    String _xifexpression = null;
+    if ((value.contains(",") || value.contains("{"))) {
+      String _xblockexpression = null;
+      {
+        String[] singleValues = value.replace("{", "").replace("}", "").trim().split(",");
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("{ ");
+        {
+          boolean _hasElements = false;
+          for(final String v : singleValues) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(", ", "");
+            }
+            String _convertStringEnumLiteral = this.convertStringEnumLiteral(type, v.trim());
+            _builder.append(_convertStringEnumLiteral);
+          }
+        }
+        _builder.append(" }");
+        _xblockexpression = _builder.toString();
+      }
+      _xifexpression = _xblockexpression;
+    } else {
+      _xifexpression = this.convertStringEnumLiteral(type, value);
+    }
+    return _xifexpression;
+  }
+  
+  private String convertStringEnumLiteral(final EnumerationType type, final String value) {
+    String v = value;
+    boolean _startsWith = v.startsWith(type.getName());
+    if (_startsWith) {
+      int _length = type.getName().length();
+      int _plus = (_length + 1);
+      v = v.substring(_plus);
+    }
+    EList<EnumLiteral> _literals = type.getLiterals();
+    for (final EnumLiteral l : _literals) {
+      boolean _equals = l.getName().equals(v);
+      if (_equals) {
+        String _name = type.getName();
+        String _plus_1 = (_name + "_");
+        String _name_1 = l.getName();
+        return (_plus_1 + _name_1);
+      }
+    }
+    return null;
+  }
+  
+  @Override
+  public String defaultValue(final DataType dt) {
+    String _switchResult = null;
+    boolean _matched = false;
+    if (dt instanceof PrimitiveType) {
+      _matched=true;
+      _switchResult = this.toValueLiteral(((PrimitiveType)dt), ((PrimitiveType)dt).getDefaultValueLiteral());
+    }
+    if (!_matched) {
+      if (dt instanceof EnumerationType) {
+        _matched=true;
+        _switchResult = this.getDefaultValue(((EnumerationType)dt));
+      }
+    }
+    if (!_matched) {
+      if (dt instanceof ExternalType) {
+        _matched=true;
+        String _xblockexpression = null;
+        {
+          String _defaultValueLiteral = ((ExternalType)dt).getDefaultValueLiteral();
+          boolean _notEquals = (!Objects.equal(_defaultValueLiteral, null));
+          if (_notEquals) {
+            return ((ExternalType)dt).getDefaultValueLiteral();
+          }
+          String _name = ((ExternalType)dt).getName();
+          String _plus = ("external type " + _name);
+          String _plus_1 = (_plus + "has no default initialization");
+          this.diagnostician.error(_plus_1, ((ExternalType)dt).eContainer(), ((ExternalType)dt).eContainingFeature());
+          _xblockexpression = "";
+        }
+        _switchResult = _xblockexpression;
+      }
+    }
+    if (!_matched) {
+      if (dt instanceof DataClass) {
+        _matched=true;
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("{");
+        _builder.newLine();
+        {
+          List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(((DataClass)dt));
+          boolean _hasElements = false;
+          for(final Attribute att : _allAttributes) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(",", "\t");
+            }
+            _builder.append("\t");
+            String _initializationWithDefaultValues = this.initializationWithDefaultValues(att);
+            _builder.append(_initializationWithDefaultValues, "\t");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _builder.append("}");
+        _builder.newLine();
+        _switchResult = _builder.toString();
+      }
+    }
+    return _switchResult;
+  }
+  
+  public String getDefaultValue(final EnumerationType type) {
+    String _xifexpression = null;
+    boolean _isEmpty = type.getLiterals().isEmpty();
+    if (_isEmpty) {
+      _xifexpression = "";
+    } else {
+      _xifexpression = this.getCastedValue(type.getLiterals().get(0));
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String initializationWithDefaultValues(final DataType dt, final int size) {
+    String _xblockexpression = null;
+    {
+      final String dv = this.defaultValue(dt);
+      _xblockexpression = this.initializer(dv, size);
+    }
+    return _xblockexpression;
+  }
+  
+  private String initializer(final String dv, final int size) {
+    String _xifexpression = null;
+    if ((size > 1)) {
+      String _xblockexpression = null;
+      {
+        String res = "{";
+        int i = 0;
+        while ((i < size)) {
+          {
+            res = (res + dv);
+            i = (i + 1);
+            if ((i < size)) {
+              res = (res + ",");
+            }
+          }
+        }
+        _xblockexpression = (res + "}");
+      }
+      _xifexpression = _xblockexpression;
+    } else {
+      _xifexpression = dv;
+    }
+    return _xifexpression;
+  }
+  
+  public String initializationWithDefaultValues(final Attribute att) {
+    String _xblockexpression = null;
+    {
+      final String dv = att.getDefaultValueLiteral();
+      String _xifexpression = null;
+      boolean _notEquals = (!Objects.equal(dv, null));
+      if (_notEquals) {
+        String _xifexpression_1 = null;
+        boolean _startsWith = dv.startsWith("{");
+        if (_startsWith) {
+          _xifexpression_1 = dv;
+        } else {
+          _xifexpression_1 = this.initializer(dv, att.getSize());
+        }
+        _xifexpression = _xifexpression_1;
+      } else {
+        String _xifexpression_2 = null;
+        boolean _isRef = att.getType().isRef();
+        if (_isRef) {
+          _xifexpression_2 = this.initializer("NULL", att.getSize());
+        } else {
+          _xifexpression_2 = this.initializationWithDefaultValues(att.getType().getType(), att.getSize());
+        }
+        _xifexpression = _xifexpression_2;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String[] generateArglistAndTypedData(final EObject d) {
+    if ((Objects.equal(d, null) || (!(d instanceof VarDecl)))) {
+      return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList("", "", ""), String.class));
+    }
+    final VarDecl data = ((VarDecl) d);
+    boolean _equals = Objects.equal(data, null);
+    if (_equals) {
+      return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList("", "", ""), String.class));
+    }
+    String _xifexpression = null;
+    DataType _type = data.getRefType().getType();
+    if ((_type instanceof PrimitiveType)) {
+      DataType _type_1 = data.getRefType().getType();
+      _xifexpression = ((PrimitiveType) _type_1).getTargetName();
+    } else {
+      String _xifexpression_1 = null;
+      DataType _type_2 = data.getRefType().getType();
+      if ((_type_2 instanceof EnumerationType)) {
+        DataType _type_3 = data.getRefType().getType();
+        _xifexpression_1 = this.getTargetType(((EnumerationType) _type_3));
+      } else {
+        String _xifexpression_2 = null;
+        DataType _type_4 = data.getRefType().getType();
+        if ((_type_4 instanceof ExternalType)) {
+          DataType _type_5 = data.getRefType().getType();
+          _xifexpression_2 = ((ExternalType) _type_5).getTargetName();
+        } else {
+          _xifexpression_2 = data.getRefType().getType().getName();
+        }
+        _xifexpression_1 = _xifexpression_2;
+      }
+      _xifexpression = _xifexpression_1;
+    }
+    String typeName = _xifexpression;
+    String _xifexpression_3 = null;
+    DataType _type_6 = data.getRefType().getType();
+    if ((_type_6 instanceof PrimitiveType)) {
+      String _xblockexpression = null;
+      {
+        DataType _type_7 = data.getRefType().getType();
+        final String ct = ((PrimitiveType) _type_7).getCastName();
+        String _xifexpression_4 = null;
+        if (((!Objects.equal(ct, null)) && (!ct.isEmpty()))) {
+          _xifexpression_4 = ct;
+        } else {
+          _xifexpression_4 = typeName;
+        }
+        _xblockexpression = _xifexpression_4;
+      }
+      _xifexpression_3 = _xblockexpression;
+    } else {
+      String _xifexpression_4 = null;
+      DataType _type_7 = data.getRefType().getType();
+      if ((_type_7 instanceof EnumerationType)) {
+        DataType _type_8 = data.getRefType().getType();
+        _xifexpression_4 = this.getCastType(((EnumerationType) _type_8));
+      } else {
+        _xifexpression_4 = typeName;
+      }
+      _xifexpression_3 = _xifexpression_4;
+    }
+    String castTypeName = _xifexpression_3;
+    castTypeName = (castTypeName + "*");
+    String deRef = "*";
+    final boolean isRef = data.getRefType().isRef();
+    final boolean isPrim = ((data.getRefType().getType() instanceof PrimitiveType) || (data.getRefType().getType() instanceof EnumerationType));
+    if (isRef) {
+      typeName = (typeName + "*");
+      castTypeName = (castTypeName + "*");
+    } else {
+      if ((!isPrim)) {
+        typeName = (typeName + "*");
+        deRef = "";
+      }
+    }
+    final String dataArg = (", " + ILanguageExtension.GENERIC_DATA_NAME);
+    final String typedData = (((((((typeName + " ") + ILanguageExtension.GENERIC_DATA_NAME) + " = ") + deRef) + "((") + castTypeName) + ") generic_data__et);\n");
+    final String typedArgList = (((", " + typeName) + " ") + ILanguageExtension.GENERIC_DATA_NAME);
+    return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList(dataArg, typedData, typedArgList), String.class));
+  }
+  
+  public String getIncludePath(final RoomClass rc) {
+    EObject _eContainer = rc.eContainer();
+    String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "/");
+    String _plus = ("\"" + _replaceAll);
+    String _plus_1 = (_plus + "/");
+    String _cHeaderFileName = this.getCHeaderFileName(rc);
+    String _plus_2 = (_plus_1 + _cHeaderFileName);
+    return (_plus_2 + "\"");
+  }
+  
+  public String getUtilsIncludePath(final RoomClass rc) {
+    EObject _eContainer = rc.eContainer();
+    String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "/");
+    String _plus = ("\"" + _replaceAll);
+    String _plus_1 = (_plus + "/");
+    String _cUtilsFileName = this.getCUtilsFileName(rc);
+    String _plus_2 = (_plus_1 + _cUtilsFileName);
+    return (_plus_2 + "\"");
+  }
+  
+  @Override
+  public String getTargetType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getTargetName();
+    } else {
+      _xifexpression = type.getName();
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String getCastedValue(final EnumLiteral literal) {
+    String _xblockexpression = null;
+    {
+      EObject _eContainer = literal.eContainer();
+      final EnumerationType type = ((EnumerationType) _eContainer);
+      final String cast = this.getTargetType(type);
+      String _xifexpression = null;
+      PrimitiveType _primitiveType = type.getPrimitiveType();
+      boolean _equals = Objects.equal(_primitiveType, null);
+      if (_equals) {
+        _xifexpression = Long.toString(literal.getLiteralValue());
+      } else {
+        String _string = Long.toString(literal.getLiteralValue());
+        String _plus = ((("((" + cast) + ")") + _string);
+        _xifexpression = (_plus + ")");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getCastType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getCastName();
+    } else {
+      _xifexpression = type.getName();
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String makeOverridable() {
+    return "";
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/DataClassGen.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/DataClassGen.java
new file mode 100644
index 000000000..2dc2a444b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/DataClassGen.java
@@ -0,0 +1,388 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (changed for C code generator)
+ */
+package org.eclipse.etrice.generator.c.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+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.Operation;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.c.gen.CExtensions;
+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.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class DataClassGen {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private CExtensions _cExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    EList<DataClass> _dataClasses = root.getDataClasses();
+    for (final DataClass dc : _dataClasses) {
+      {
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(dc);
+        String _path = this._roomExtensions.getPath(dc);
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(dc);
+        String _path_1 = this._roomExtensions.getPath(dc);
+        final String infopath = (_generationInfoPath + _path_1);
+        String file = this._cExtensions.getCHeaderFileName(dc);
+        this.fileIO.generateFile("generating DataClass header", path, infopath, file, this.generateHeaderFile(root, dc));
+        file = this._cExtensions.getCUtilsFileName(dc);
+        this.fileIO.generateFile("generating ProtocolClass utils", path, infopath, file, this.generateUtilsFile(root, dc));
+        file = this._cExtensions.getCSourceFileName(dc);
+        this.fileIO.generateFile("generating DataClass source", path, infopath, file, this.generateSourceFile(root, dc));
+      }
+    }
+  }
+  
+  public CharSequence generateHeaderFile(final Root root, final DataClass dc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Header File of DataClass ");
+    String _name = dc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("* ");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(dc);
+    _builder.append(_generateIncludeGuardBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"etDatatypes.h\"");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("/* include all referenced room classes */");
+    _builder.newLine();
+    {
+      EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(dc);
+      EList<EnumerationType> _referencedEnumClasses = root.getReferencedEnumClasses(dc);
+      final Function1<DataType, String> _function = (DataType it) -> {
+        return it.getName();
+      };
+      List<DataType> _sortBy = IterableExtensions.<DataType, String>sortBy(Iterables.<DataType>concat(_referencedDataClasses, _referencedEnumClasses), _function);
+      for(final DataType rc : _sortBy) {
+        _builder.append("#include ");
+        String _includePath = this._cExtensions.getIncludePath(rc);
+        _builder.append(_includePath);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.newLine();
+    CharSequence _userCode = this._procedureHelpers.userCode(dc, 1);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.newLine();
+    _builder.append("typedef struct {");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _attributes = this._procedureHelpers.attributes(this._roomHelpers.getAllAttributes(dc));
+    _builder.append(_attributes, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("} ");
+    String _name_1 = dc.getName();
+    _builder.append(_name_1);
+    _builder.append(";");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    {
+      List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dc);
+      for(final Attribute a : _allAttributes) {
+        {
+          String _defaultValueLiteral = a.getDefaultValueLiteral();
+          boolean _notEquals = (!Objects.equal(_defaultValueLiteral, null));
+          if (_notEquals) {
+            String _name_2 = dc.getName();
+            String _plus = (_name_2 + " ");
+            String _name_3 = a.getName();
+            String _plus_1 = (_plus + _name_3);
+            String _plus_2 = (_plus_1 + ": Attribute initialization not supported in C");
+            this.logger.logInfo(_plus_2);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _operationsDeclaration = this._procedureHelpers.operationsDeclaration(dc.getOperations(), dc.getName());
+    _builder.append(_operationsDeclaration);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* deep copy */");
+    _builder.newLine();
+    _builder.append("void ");
+    String _name_4 = dc.getName();
+    _builder.append(_name_4);
+    _builder.append("_deepCopy(");
+    String _name_5 = dc.getName();
+    _builder.append(_name_5);
+    _builder.append("* source, ");
+    String _name_6 = dc.getName();
+    _builder.append(_name_6);
+    _builder.append("* target);");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _userCode_1 = this._procedureHelpers.userCode(dc, 2);
+    _builder.append(_userCode_1);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(dc);
+    _builder.append(_generateIncludeGuardEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence generateUtilsFile(final Root root, final DataClass dc) {
+    CharSequence _xblockexpression = null;
+    {
+      EObject _eContainer = dc.eContainer();
+      String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "_");
+      String _plus = (_replaceAll + "_");
+      String _name = dc.getName();
+      String _plus_1 = (_plus + _name);
+      final String filename = (_plus_1 + "_Utils");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Utils File of DataClass ");
+      String _name_1 = dc.getName();
+      _builder.append(_name_1, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("* ");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(filename);
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include ");
+      String _includePath = this._cExtensions.getIncludePath(dc);
+      _builder.append(_includePath);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* access macros for operations and attributes");
+      _builder.newLine();
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* operations */");
+      _builder.newLine();
+      {
+        List<StandardOperation> _allOperations = this._roomHelpers.getAllOperations(dc);
+        for(final StandardOperation op : _allOperations) {
+          final CharSequence args = this.argList(op);
+          _builder.newLineIfNotEmpty();
+          _builder.append("#define ");
+          String _name_2 = op.getName();
+          _builder.append(_name_2);
+          _builder.append("(");
+          _builder.append(args);
+          _builder.append(") ");
+          String _name_3 = dc.getName();
+          _builder.append(_name_3);
+          _builder.append("_");
+          String _name_4 = op.getName();
+          _builder.append(_name_4);
+          _builder.append("(self");
+          {
+            boolean _isEmpty = op.getArguments().isEmpty();
+            boolean _not = (!_isEmpty);
+            if (_not) {
+              _builder.append(", ");
+              _builder.append(args);
+            }
+          }
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* attributes */");
+      _builder.newLine();
+      {
+        List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dc);
+        for(final Attribute a : _allAttributes) {
+          _builder.append("#define ");
+          String _name_5 = a.getName();
+          _builder.append(_name_5);
+          _builder.append(" (self->");
+          String _name_6 = a.getName();
+          _builder.append(_name_6);
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(filename);
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence argList(final Operation op) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<VarDecl> _arguments = op.getArguments();
+      boolean _hasElements = false;
+      for(final VarDecl a : _arguments) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(", ", "");
+        }
+        String _name = a.getName();
+        _builder.append(_name);
+      }
+    }
+    return _builder;
+  }
+  
+  public CharSequence generateSourceFile(final Root root, final DataClass dc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Source File of DataClass ");
+    String _name = dc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("* ");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("#include <string.h>");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("#include \"");
+    String _cHeaderFileName = this._cExtensions.getCHeaderFileName(dc);
+    _builder.append(_cHeaderFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.append("#include \"");
+    String _cUtilsFileName = this._cExtensions.getCUtilsFileName(dc);
+    _builder.append(_cUtilsFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _userCode = this._procedureHelpers.userCode(dc, 3);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(dc.getOperations(), dc.getName());
+    _builder.append(_operationsImplementation);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("void ");
+    String _name_1 = dc.getName();
+    _builder.append(_name_1);
+    _builder.append("_deepCopy(");
+    String _name_2 = dc.getName();
+    _builder.append(_name_2);
+    _builder.append("* source, ");
+    String _name_3 = dc.getName();
+    _builder.append(_name_3);
+    _builder.append("* target) {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("memcpy(target, source, sizeof(");
+    String _name_4 = dc.getName();
+    _builder.append(_name_4, "\t");
+    _builder.append("));");
+    _builder.newLineIfNotEmpty();
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.newLine();
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/NodeGen.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/NodeGen.java
new file mode 100644
index 000000000..9a4e24a41
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/NodeGen.java
@@ -0,0 +1,2516 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (changed for C code generator)
+ */
+package org.eclipse.etrice.generator.c.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.common.base.LiteralType;
+import org.eclipse.etrice.core.common.converter.TimeConverter;
+import org.eclipse.etrice.core.etmap.util.ETMapUtil;
+import org.eclipse.etrice.core.etphys.eTPhys.ExecMode;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.etphys.eTPhys.PhysicalThread;
+import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+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.StructureInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+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.CommunicationType;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.EnumerationType;
+import org.eclipse.etrice.core.room.GeneralProtocolClass;
+import org.eclipse.etrice.core.room.InterfaceItem;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageHandler;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.PortClass;
+import org.eclipse.etrice.core.room.PrimitiveType;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.RoomClass;
+import org.eclipse.etrice.core.room.SAP;
+import org.eclipse.etrice.core.room.SPP;
+import org.eclipse.etrice.core.room.SubSystemClass;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.c.Main;
+import org.eclipse.etrice.generator.c.gen.CExtensions;
+import org.eclipse.etrice.generator.c.gen.Initialization;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.fsm.base.IntelligentSeparator;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IntegerRange;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class NodeGen {
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private CExtensions _cExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers helpers;
+  
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  private Initialization attrInitGenAddon;
+  
+  @Inject
+  private IDiagnostician diagnostician;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    Collection<NodeRef> _nodeRefs = ETMapUtil.getNodeRefs();
+    for (final NodeRef nr : _nodeRefs) {
+      List<String> _subSystemInstancePaths = ETMapUtil.getSubSystemInstancePaths(nr);
+      for (final String instpath : _subSystemInstancePaths) {
+        {
+          StructureInstance _instance = root.getInstance(instpath);
+          final SubSystemInstance ssi = ((SubSystemInstance) _instance);
+          boolean _notEquals = (!Objects.equal(ssi, null));
+          if (_notEquals) {
+            String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(ssi.getSubSystemClass());
+            String _path = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String filepath = (_generationTargetPath + _path);
+            String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(ssi.getSubSystemClass());
+            String _path_1 = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String infopath = (_generationInfoPath + _path_1);
+            String file = this._cExtensions.getCHeaderFileName(nr, ssi);
+            this.checkDataPorts(ssi);
+            final Set<PhysicalThread> usedThreads = ETMapUtil.getUsedThreads(nr, ssi);
+            this.fileIO.generateFile("generating Node declaration", filepath, infopath, file, this.generateHeaderFile(root, ssi));
+            file = this._cExtensions.getCSourceFileName(nr, ssi);
+            this.fileIO.generateFile("generating Node implementation", filepath, infopath, file, this.generateSourceFile(root, ssi, usedThreads));
+            file = this._cExtensions.getInstSourceFileName(nr, ssi);
+            this.fileIO.generateFile("generating Node instance file", filepath, infopath, file, this.generateInstanceFile(root, ssi, usedThreads));
+            file = this._cExtensions.getDispSourceFileName(nr, ssi);
+            this.fileIO.generateFile("generating Node dispatcher file", filepath, infopath, file, this.generateDispatcherFile(root, ssi, usedThreads));
+          }
+        }
+      }
+    }
+  }
+  
+  private CharSequence generateHeaderFile(final Root root, final SubSystemInstance ssi) {
+    CharSequence _xblockexpression = null;
+    {
+      final NodeRef nr = ETMapUtil.getNodeRef(ssi);
+      final SubSystemClass ssc = ssi.getSubSystemClass();
+      String _name = nr.getName();
+      String _plus = (_name + "_");
+      String _name_1 = ssi.getName();
+      final String clsname = (_plus + _name_1);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Header File of Node ");
+      String _name_2 = nr.getName();
+      _builder.append(_name_2, " ");
+      _builder.append(" with SubSystem ");
+      String _name_3 = ssi.getName();
+      _builder.append(_name_3, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(clsname);
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"etDatatypes.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _userCode = this.helpers.userCode(ssc.getUserCode1());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* lifecycle functions");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* init -> start -> run (loop) -> stop -> destroy");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_init(void);\t\t/* lifecycle init  \t */");
+      _builder.newLineIfNotEmpty();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_start(void);\t/* lifecycle start \t */");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_run(etBool runAsTest);\t\t/* lifecycle run \t */");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_stop(void); \t/* lifecycle stop\t */");
+      _builder.newLineIfNotEmpty();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_destroy(void); \t/* lifecycle destroy */");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_shutdown(void);  /* shutdown the dispatcher loop */");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _userCode_1 = this.helpers.userCode(ssc.getUserCode2());
+      _builder.append(_userCode_1);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(clsname);
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateSourceFile(final Root root, final SubSystemInstance ssi, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final NodeRef nr = ETMapUtil.getNodeRef(ssi);
+      final SubSystemClass ssc = ssi.getSubSystemClass();
+      String _name = nr.getName();
+      String _plus = (_name + "_");
+      String _name_1 = ssi.getName();
+      final String clsname = (_plus + _name_1);
+      final Function1<PhysicalThread, Boolean> _function = (PhysicalThread t) -> {
+        return Boolean.valueOf(usedThreads.contains(t));
+      };
+      final Iterable<PhysicalThread> threads = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function);
+      final boolean logData = (Main.getSettings().isGenerateDataInstrumentation() && this._roomHelpers.isAnnotationPresent(ssc.getAnnotations(), "DataLogging"));
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Source File of Node ");
+      String _name_2 = nr.getName();
+      _builder.append(_name_2, " ");
+      _builder.append(" with SubSystem ");
+      String _name_3 = ssi.getName();
+      _builder.append(_name_3, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include <stdio.h>");
+      _builder.newLine();
+      _builder.append("#include <string.h>");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cHeaderFileName = this._cExtensions.getCHeaderFileName(nr, ssi);
+      _builder.append(_cHeaderFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"debugging/etLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etMSCLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etDataLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"messaging/etSystemProtocol.h\"");
+      _builder.newLine();
+      _builder.append("#include \"osal/etTimer.h\"");
+      _builder.newLine();
+      _builder.append("#include \"osal/etSema.h\"");
+      _builder.newLine();
+      _builder.append("#include \"runtime/etRuntime.h\"");
+      _builder.newLine();
+      _builder.append("#include \"etRuntimeConfig.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _userCode = this.helpers.userCode(ssc.getUserCode3());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/* data for Node ");
+      String _name_4 = nr.getName();
+      _builder.append(_name_4);
+      _builder.append(" with SubSystem ");
+      String _name_5 = ssi.getName();
+      _builder.append(_name_5);
+      _builder.append(" */");
+      _builder.newLineIfNotEmpty();
+      _builder.append("typedef struct ");
+      _builder.append(clsname);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("char *name;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("volatile int shutdownRequest;");
+      _builder.newLine();
+      _builder.append("} ");
+      _builder.append(clsname);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("static ");
+      _builder.append(clsname);
+      _builder.append(" ");
+      _builder.append(clsname);
+      _builder.append("Inst = {\"");
+      _builder.append(clsname);
+      _builder.append("\", 0};");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_initActorInstances(void);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_constructActorInstances(void);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/* include instances for all classes */");
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _instSourceFileName = this._cExtensions.getInstSourceFileName(nr, ssi);
+      _builder.append(_instSourceFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.append("#include \"");
+      String _dispSourceFileName = this._cExtensions.getDispSourceFileName(nr, ssi);
+      _builder.append(_dispSourceFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_initMessageServices(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"initMessageServices\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("etTime interval;");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("/* initialization of all message services */");
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Long> _function_1 = (PhysicalThread it) -> {
+          long _prio = it.getPrio();
+          return Long.valueOf((-_prio));
+        };
+        List<PhysicalThread> _sortBy = IterableExtensions.<PhysicalThread, Long>sortBy(threads, _function_1);
+        for(final PhysicalThread thread : _sortBy) {
+          {
+            if ((Objects.equal(thread.getExecmode(), ExecMode.POLLED) || Objects.equal(thread.getExecmode(), ExecMode.MIXED))) {
+              _builder.append("\t\t");
+              _builder.append("interval.sec = ");
+              long _split = TimeConverter.split(thread.getTime(), TimeConverter.SEC, true);
+              _builder.append(_split, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("interval.nSec = ");
+              long _split_1 = TimeConverter.split(thread.getTime(), TimeConverter.MILLI_SEC, false);
+              _builder.append(_split_1, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t\t");
+          _builder.append("etMessageService_init(");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("&msgService_");
+          String _name_6 = thread.getName();
+          _builder.append(_name_6, "\t\t\t");
+          _builder.append(",");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("msgBuffer_");
+          String _name_7 = thread.getName();
+          _builder.append(_name_7, "\t\t\t");
+          _builder.append(",");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          String _upperCase = thread.getName().toUpperCase();
+          _builder.append(_upperCase, "\t\t\t");
+          _builder.append("_POOL_SIZE,");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          String _upperCase_1 = thread.getName().toUpperCase();
+          _builder.append(_upperCase_1, "\t\t\t");
+          _builder.append("_BLOCK_SIZE,");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          int _stacksize = thread.getStacksize();
+          _builder.append(_stacksize, "\t\t\t");
+          _builder.append(",");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          long _prio = thread.getPrio();
+          _builder.append(_prio, "\t\t\t");
+          _builder.append(",");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("interval,");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("MsgDispatcher_");
+          String _name_8 = thread.getName();
+          _builder.append(_name_8, "\t\t\t");
+          _builder.append("_receiveMessage,");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("EXECMODE_");
+          String _upperCase_2 = thread.getExecmode().toString().toUpperCase();
+          _builder.append(_upperCase_2, "\t\t\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_startMessageServices(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"startMessageServices\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Long> _function_2 = (PhysicalThread it) -> {
+          long _prio_1 = it.getPrio();
+          return Long.valueOf((-_prio_1));
+        };
+        List<PhysicalThread> _sortBy_1 = IterableExtensions.<PhysicalThread, Long>sortBy(threads, _function_2);
+        for(final PhysicalThread thread_1 : _sortBy_1) {
+          _builder.append("\t");
+          _builder.append("etMessageService_start(&msgService_");
+          String _name_9 = thread_1.getName();
+          _builder.append(_name_9, "\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_stopMessageServices(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"stopMessageServices\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        for(final PhysicalThread thread_2 : threads) {
+          _builder.append("\t");
+          _builder.append("etMessageService_stop(&msgService_");
+          String _name_10 = thread_2.getName();
+          _builder.append(_name_10, "\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_destroyMessageServices(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"destroyMessageServices\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        for(final PhysicalThread thread_3 : threads) {
+          _builder.append("\t");
+          _builder.append("etMessageService_destroy(&msgService_");
+          String _name_11 = thread_3.getName();
+          _builder.append(_name_11, "\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_init(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"init\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("etLogger_logInfoF(\"%s_init\", ");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.name);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* construct all actors */");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_constructActorInstances();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* initialization of all message services */");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_initMessageServices();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* init all actors */");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_initActorInstances();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if (logData) {
+          {
+            for(final PhysicalThread thread_4 : threads) {
+              _builder.append("\t");
+              _builder.append("MsgDispatcher_");
+              String _name_12 = thread_4.getName();
+              _builder.append(_name_12, "\t");
+              _builder.append("_logDataHeaders();");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          {
+            for(final PhysicalThread thread_5 : threads) {
+              _builder.append("\t");
+              _builder.append("MsgDispatcher_");
+              String _name_13 = thread_5.getName();
+              _builder.append(_name_13, "\t");
+              _builder.append("_logData();");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_start(void) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"start\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("etLogger_logInfoF(\"%s_start\", ");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.name);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_startMessageServices();");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_run(etBool runAsTest) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("#ifdef ET_RUNNER_ACTIVATE");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"run\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("if (runAsTest) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("etSema_waitForWakeup(etRuntime_getTerminateSemaphore());");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("else {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("printf(\"type quit to exit\\n\");");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("fflush(stdout);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("while (ET_TRUE) {");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("char line[64];");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("if (fgets(line, 64, stdin) != NULL) {");
+      _builder.newLine();
+      _builder.append("\t\t\t\t");
+      _builder.append("if (strncmp(line, \"quit\", 4)==0)");
+      _builder.newLine();
+      _builder.append("\t\t\t\t\t");
+      _builder.append("break;");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("#endif");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_stop(void){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"stop\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("etLogger_logInfoF(\"%s_stop\", ");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.name);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_stopMessageServices();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_destroy(void){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"destroy\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("etLogger_logInfoF(\"%s_destroy\", ");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.name);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances = ssi.getAllContainedInstances();
+        for(final ActorInstance ai : _allContainedInstances) {
+          _builder.append("\t");
+          ActorClass _actorClass = ai.getActorClass();
+          String _pathName = this._roomExtensions.getPathName(ai.getPath());
+          String _plus_1 = ("&" + _pathName);
+          String _invokeUserStructor = this.helpers.invokeUserStructor(_actorClass, _plus_1, false);
+          _builder.append(_invokeUserStructor, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("_destroyMessageServices();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("_shutdown(void){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"shutdown\")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("etLogger_logInfoF(\"%s_shutdown\", ");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.name);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append(clsname, "\t");
+      _builder.append("Inst.shutdownRequest = 1;");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_constructActorInstances(void){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"constructActorInstances\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances_1 = ssi.getAllContainedInstances();
+        for(final ActorInstance ai_1 : _allContainedInstances_1) {
+          _builder.append("\t");
+          ActorClass _actorClass_1 = ai_1.getActorClass();
+          String _pathName_1 = this._roomExtensions.getPathName(ai_1.getPath());
+          String _plus_2 = ("&" + _pathName_1);
+          String _invokeUserStructor_1 = this.helpers.invokeUserStructor(_actorClass_1, _plus_2, true);
+          _builder.append(_invokeUserStructor_1, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("static void ");
+      _builder.append(clsname);
+      _builder.append("_initActorInstances(void){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+      _builder.append(clsname, "\t");
+      _builder.append("\", \"initActorInstances\")");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances_2 = ssi.getAllContainedInstances();
+        for(final ActorInstance ai_2 : _allContainedInstances_2) {
+          _builder.append("\t");
+          String _name_14 = ai_2.getActorClass().getName();
+          _builder.append(_name_14, "\t");
+          _builder.append("_init(&");
+          String _pathName_2 = this._roomExtensions.getPathName(ai_2.getPath());
+          _builder.append(_pathName_2, "\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateInstanceFile(final Root root, final SubSystemInstance ssi, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final NodeRef nr = ETMapUtil.getNodeRef(ssi);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Instance File of Node ");
+      String _name = nr.getName();
+      _builder.append(_name, " ");
+      _builder.append(" with SubSystem ");
+      String _name_1 = ssi.getName();
+      _builder.append(_name_1, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("* - instantiation of all actor instances and port instances");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* - configuration of data and connection of ports");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"messaging/etMessageService.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* include all referenced room classes */");
+      _builder.newLine();
+      {
+        EList<ActorClass> _referencedActorClasses = root.getReferencedActorClasses(ssi.getSubSystemClass());
+        EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(ssi.getSubSystemClass());
+        final Function1<RoomClass, String> _function = (RoomClass it) -> {
+          return it.getName();
+        };
+        List<RoomClass> _sortBy = IterableExtensions.<RoomClass, String>sortBy(Iterables.<RoomClass>concat(_referencedActorClasses, _referencedProtocolClasses), _function);
+        for(final RoomClass dc : _sortBy) {
+          _builder.append("#include ");
+          String _includePath = this._cExtensions.getIncludePath(dc);
+          _builder.append(_includePath);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* instantiation of message services and message buffers */");
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Boolean> _function_1 = (PhysicalThread t) -> {
+          return Boolean.valueOf(usedThreads.contains(t));
+        };
+        Iterable<PhysicalThread> _filter = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function_1);
+        for(final PhysicalThread thread : _filter) {
+          _builder.append("/* ");
+          String _name_2 = thread.getName();
+          _builder.append(_name_2);
+          _builder.append(" */");
+          _builder.newLineIfNotEmpty();
+          _builder.append("#define ");
+          String _upperCase = thread.getName().toUpperCase();
+          _builder.append(_upperCase);
+          _builder.append("_POOL_SIZE\t\t");
+          int _msgpoolsize = thread.getMsgpoolsize();
+          _builder.append(_msgpoolsize);
+          _builder.newLineIfNotEmpty();
+          _builder.append("#define ");
+          String _upperCase_1 = thread.getName().toUpperCase();
+          _builder.append(_upperCase_1);
+          _builder.append("_BLOCK_SIZE\t");
+          int _msgblocksize = thread.getMsgblocksize();
+          _builder.append(_msgblocksize);
+          _builder.newLineIfNotEmpty();
+          _builder.append("static uint8 msgBuffer_");
+          String _name_3 = thread.getName();
+          _builder.append(_name_3);
+          _builder.append("[");
+          String _upperCase_2 = thread.getName().toUpperCase();
+          _builder.append(_upperCase_2);
+          _builder.append("_POOL_SIZE * ");
+          String _upperCase_3 = thread.getName().toUpperCase();
+          _builder.append(_upperCase_3);
+          _builder.append("_BLOCK_SIZE];");
+          _builder.newLineIfNotEmpty();
+          _builder.append("static etMessageService msgService_");
+          String _name_4 = thread.getName();
+          _builder.append(_name_4);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* declarations of all ActorClass instances (const and variable structs) */");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("/* forward declaration of variable actor structs */");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances = ssi.getAllContainedInstances();
+        for(final ActorInstance ai : _allContainedInstances) {
+          _builder.append("static ");
+          String _name_5 = ai.getActorClass().getName();
+          _builder.append(_name_5);
+          _builder.append(" ");
+          String _pathName = this._roomExtensions.getPathName(ai.getPath());
+          _builder.append(_pathName);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* forward declaration of variable port structs */");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances_1 = ssi.getAllContainedInstances();
+        for(final ActorInstance ai_1 : _allContainedInstances_1) {
+          {
+            boolean _isEmpty = ai_1.getOrderedIfItemInstances().isEmpty();
+            if (_isEmpty) {
+              _builder.append("/* nothing to do */");
+              _builder.newLine();
+            } else {
+              {
+                EList<InterfaceItemInstance> _orderedIfItemInstances = ai_1.getOrderedIfItemInstances();
+                for(final InterfaceItemInstance pi : _orderedIfItemInstances) {
+                  {
+                    PortClass _portClass = this._roomExtensions.getPortClass(pi.getProtocol(), this._roomExtensions.isConjugated(pi));
+                    EList<Attribute> _attributes = null;
+                    if (_portClass!=null) {
+                      _attributes=_portClass.getAttributes();
+                    }
+                    int _size = 0;
+                    if (_attributes!=null) {
+                      _size=_attributes.size();
+                    }
+                    boolean _greaterThan = (_size > 0);
+                    if (_greaterThan) {
+                      _builder.append("static ");
+                      String _portClassName = this._roomExtensions.getPortClassName(pi.getProtocol(), this._roomExtensions.isConjugated(pi));
+                      _builder.append(_portClassName);
+                      _builder.append("_var ");
+                      String _pathName_1 = this._roomExtensions.getPathName(pi.getPath());
+                      _builder.append(_pathName_1);
+                      _builder.append("_var");
+                      {
+                        boolean _isReplicated = pi.isReplicated();
+                        if (_isReplicated) {
+                          _builder.append("[");
+                          int _size_1 = pi.getPeers().size();
+                          _builder.append(_size_1);
+                          _builder.append("]");
+                        }
+                      }
+                      _builder.append("={");
+                      _builder.newLineIfNotEmpty();
+                      {
+                        int _xifexpression = (int) 0;
+                        int _size_2 = pi.getPeers().size();
+                        boolean _equals = (_size_2 == 0);
+                        if (_equals) {
+                          _xifexpression = 1;
+                        } else {
+                          _xifexpression = pi.getPeers().size();
+                        }
+                        IntegerRange _upTo = new IntegerRange(1, _xifexpression);
+                        boolean _hasElements = false;
+                        for(final Integer i : _upTo) {
+                          if (!_hasElements) {
+                            _hasElements = true;
+                          } else {
+                            _builder.appendImmediate(", ", "\t");
+                          }
+                          _builder.append("\t");
+                          CharSequence _generateAttributeInit = this.attrInitGenAddon.generateAttributeInit(pi, this._roomHelpers.getPortClass(pi.getInterfaceItem()).getAttributes());
+                          _builder.append(_generateAttributeInit, "\t");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t\t\t\t\t\t\t");
+                        }
+                      }
+                      _builder.append("};");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances_2 = ssi.getAllContainedInstances();
+        for(final ActorInstance ai_2 : _allContainedInstances_2) {
+          _builder.newLine();
+          _builder.append("/* instance ");
+          String _pathName_2 = this._roomExtensions.getPathName(ai_2.getPath());
+          _builder.append(_pathName_2);
+          _builder.append(" */");
+          _builder.newLineIfNotEmpty();
+          {
+            if (((!Main.getSettings().isGenerateMSCInstrumentation()) && ai_2.getOrderedIfItemInstances().isEmpty())) {
+              _builder.append("/* no ports/saps/services - nothing to initialize statically */");
+              _builder.newLine();
+            } else {
+              CharSequence _genActorInstanceInitializer = this.genActorInstanceInitializer(root, ai_2);
+              _builder.append(_genActorInstanceInitializer);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genActorInstanceInitializer(final Root root, final ActorInstance ai) {
+    CharSequence _xblockexpression = null;
+    {
+      final String instName = this._roomExtensions.getPathName(ai.getPath());
+      final ArrayList<InterfaceItemInstance> replEventItems = new ArrayList<InterfaceItemInstance>();
+      final Function1<InterfaceItemInstance, Boolean> _function = (InterfaceItemInstance e) -> {
+        return Boolean.valueOf(e.isReplicated());
+      };
+      Iterables.<InterfaceItemInstance>addAll(replEventItems, IterableExtensions.<InterfaceItemInstance>filter(ai.getOrderedIfItemInstances(), _function));
+      final Function1<InterfaceItemInstance, Boolean> _function_1 = (InterfaceItemInstance e) -> {
+        boolean _isEmpty = e.getPeers().isEmpty();
+        return Boolean.valueOf((!_isEmpty));
+      };
+      InterfaceItemInstance _findFirst = IterableExtensions.<InterfaceItemInstance>findFirst(replEventItems, _function_1);
+      final boolean haveReplSubItems = (!Objects.equal(_findFirst, null));
+      final Function1<InterfaceItemInstance, Boolean> _function_2 = (InterfaceItemInstance i) -> {
+        InterfaceItem _interfaceItem = i.getInterfaceItem();
+        return Boolean.valueOf((_interfaceItem instanceof Port));
+      };
+      final Iterable<InterfaceItemInstance> replEventPorts = IterableExtensions.<InterfaceItemInstance>filter(replEventItems, _function_2);
+      final Function1<InterfaceItemInstance, Boolean> _function_3 = (InterfaceItemInstance i) -> {
+        InterfaceItem _interfaceItem = i.getInterfaceItem();
+        return Boolean.valueOf((_interfaceItem instanceof SPP));
+      };
+      final Iterable<InterfaceItemInstance> replEventSPPs = IterableExtensions.<InterfaceItemInstance>filter(replEventItems, _function_3);
+      final Function1<InterfaceItemInstance, Boolean> _function_4 = (InterfaceItemInstance e) -> {
+        return Boolean.valueOf(e.isSimple());
+      };
+      final Iterable<InterfaceItemInstance> simplePorts = IterableExtensions.<InterfaceItemInstance>filter(ai.getOrderedIfItemInstances(), _function_4);
+      final ArrayList<InterfaceItemInstance> simpleEventItems = new ArrayList<InterfaceItemInstance>();
+      final Function1<InterfaceItemInstance, Boolean> _function_5 = (InterfaceItemInstance p) -> {
+        CommunicationType _commType = p.getProtocol().getCommType();
+        return Boolean.valueOf(Objects.equal(_commType, CommunicationType.EVENT_DRIVEN));
+      };
+      Iterables.<InterfaceItemInstance>addAll(simpleEventItems, IterableExtensions.<InterfaceItemInstance>filter(simplePorts, _function_5));
+      final Function1<InterfaceItemInstance, Boolean> _function_6 = (InterfaceItemInstance i) -> {
+        InterfaceItem _interfaceItem = i.getInterfaceItem();
+        return Boolean.valueOf((_interfaceItem instanceof Port));
+      };
+      final Iterable<InterfaceItemInstance> simpleEventPorts = IterableExtensions.<InterfaceItemInstance>filter(simpleEventItems, _function_6);
+      final Function1<InterfaceItemInstance, Boolean> _function_7 = (InterfaceItemInstance i) -> {
+        InterfaceItem _interfaceItem = i.getInterfaceItem();
+        return Boolean.valueOf((_interfaceItem instanceof SAP));
+      };
+      final Iterable<InterfaceItemInstance> simpleEventSAPs = IterableExtensions.<InterfaceItemInstance>filter(simpleEventItems, _function_7);
+      final Function1<InterfaceItemInstance, Boolean> _function_8 = (InterfaceItemInstance p) -> {
+        CommunicationType _commType = p.getProtocol().getCommType();
+        return Boolean.valueOf(Objects.equal(_commType, CommunicationType.DATA_DRIVEN));
+      };
+      final Iterable<InterfaceItemInstance> dataPorts = IterableExtensions.<InterfaceItemInstance>filter(simplePorts, _function_8);
+      final Function1<InterfaceItemInstance, Boolean> _function_9 = (InterfaceItemInstance p) -> {
+        return Boolean.valueOf(((p instanceof PortInstance) && (!((PortInstance) p).getPort().isConjugated())));
+      };
+      final Iterable<InterfaceItemInstance> recvPorts = IterableExtensions.<InterfaceItemInstance>filter(dataPorts, _function_9);
+      final Function1<InterfaceItemInstance, Boolean> _function_10 = (InterfaceItemInstance p) -> {
+        return Boolean.valueOf(((p instanceof PortInstance) && ((PortInstance) p).getPort().isConjugated()));
+      };
+      final Iterable<InterfaceItemInstance> sendPorts = IterableExtensions.<InterfaceItemInstance>filter(dataPorts, _function_10);
+      final HashMap<InterfaceItemInstance, Integer> offsets = new HashMap<InterfaceItemInstance, Integer>();
+      int offset = 0;
+      for (final InterfaceItemInstance p : replEventItems) {
+        {
+          offsets.put(p, Integer.valueOf(offset));
+          int _size = p.getPeers().size();
+          int _plus = (offset + _size);
+          offset = _plus;
+        }
+      }
+      String _xifexpression = null;
+      if (haveReplSubItems) {
+        _xifexpression = (instName + "_repl_sub_ports");
+      } else {
+        _xifexpression = "NULL";
+      }
+      String replSubPortsArray = _xifexpression;
+      final boolean haveConstData = ((((!simpleEventItems.isEmpty()) || (!IterableExtensions.isEmpty(recvPorts))) || (!replEventItems.isEmpty())) || Main.getSettings().isGenerateMSCInstrumentation());
+      final IntelligentSeparator sep = new IntelligentSeparator(",");
+      String _xifexpression_1 = null;
+      boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+      if (_isGenerateMSCInstrumentation) {
+        _xifexpression_1 = "/*const*/";
+      } else {
+        _xifexpression_1 = "const";
+      }
+      final String const_ = _xifexpression_1;
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          CharSequence _genPeerPortArrays = this.genPeerPortArrays(root, ai);
+          _builder.append(_genPeerPortArrays);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        if (haveReplSubItems) {
+          _builder.append("static const etReplSubPort ");
+          _builder.append(replSubPortsArray);
+          _builder.append("[");
+          _builder.append(offset);
+          _builder.append("] = {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("/* Replicated Sub Ports: {varData, msgService, peerAddress, localId, index} */");
+          _builder.newLine();
+          {
+            final Function1<InterfaceItemInstance, Boolean> _function_11 = (InterfaceItemInstance e) -> {
+              boolean _isEmpty = e.getPeers().isEmpty();
+              return Boolean.valueOf((!_isEmpty));
+            };
+            Iterable<InterfaceItemInstance> _filter = IterableExtensions.<InterfaceItemInstance>filter(replEventItems, _function_11);
+            boolean _hasElements = false;
+            for(final InterfaceItemInstance pi : _filter) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate(",", "\t");
+              }
+              _builder.append("\t");
+              String _genReplSubPortInitializers = this.genReplSubPortInitializers(root, ai, pi);
+              _builder.append(_genReplSubPortInitializers, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("};");
+          _builder.newLine();
+        }
+      }
+      {
+        if (haveConstData) {
+          _builder.append("static ");
+          _builder.append(const_);
+          _builder.append(" ");
+          String _name = ai.getActorClass().getName();
+          _builder.append(_name);
+          _builder.append("_const ");
+          _builder.append(instName);
+          _builder.append("_const = {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation_2) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              _builder.append("\"");
+              String _path = ai.getPath();
+              _builder.append(_path, "\t");
+              _builder.append("\"");
+              _builder.newLineIfNotEmpty();
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("/* Ports: {varData, msgService, peerAddress, localId} */");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* simple ports */");
+          _builder.newLine();
+          {
+            for(final InterfaceItemInstance pi_1 : simpleEventPorts) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              String _genPortInitializer = this.genPortInitializer(root, ai, pi_1);
+              _builder.append(_genPortInitializer, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* data receive ports */");
+          _builder.newLine();
+          {
+            for(final InterfaceItemInstance pi_2 : recvPorts) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              String _genRecvPortInitializer = this.genRecvPortInitializer(root, ai, pi_2);
+              _builder.append(_genRecvPortInitializer, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* saps */");
+          _builder.newLine();
+          {
+            for(final InterfaceItemInstance pi_3 : simpleEventSAPs) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              String _genPortInitializer_1 = this.genPortInitializer(root, ai, pi_3);
+              _builder.append(_genPortInitializer_1, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* replicated ports */");
+          _builder.newLine();
+          {
+            for(final InterfaceItemInstance pi_4 : replEventPorts) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              _builder.append("{");
+              int _size = pi_4.getPeers().size();
+              _builder.append(_size, "\t");
+              _builder.append(", ");
+              _builder.append(replSubPortsArray, "\t");
+              _builder.append("+");
+              Integer _get = offsets.get(pi_4);
+              _builder.append(_get, "\t");
+              _builder.append("}");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* services */");
+          _builder.newLine();
+          {
+            for(final InterfaceItemInstance pi_5 : replEventSPPs) {
+              _builder.append("\t");
+              _builder.append(sep, "\t");
+              _builder.append("{");
+              int _size_1 = pi_5.getPeers().size();
+              _builder.append(_size_1, "\t");
+              _builder.append(", ");
+              _builder.append(replSubPortsArray, "\t");
+              _builder.append("+");
+              Integer _get_1 = offsets.get(pi_5);
+              _builder.append(_get_1, "\t");
+              _builder.append("}");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("};");
+          _builder.newLine();
+        }
+      }
+      _builder.append("static ");
+      String _name_1 = ai.getActorClass().getName();
+      _builder.append(_name_1);
+      _builder.append(" ");
+      _builder.append(instName);
+      _builder.append(" = {");
+      _builder.newLineIfNotEmpty();
+      {
+        if (haveConstData) {
+          _builder.append("\t");
+          _builder.append("&");
+          _builder.append(instName, "\t");
+          _builder.append("_const,");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("/* data send ports */");
+      _builder.newLine();
+      {
+        for(final InterfaceItemInstance pi_6 : sendPorts) {
+          _builder.append("\t");
+          CharSequence _genSendPortInitializer = this.genSendPortInitializer(pi_6);
+          _builder.append(_genSendPortInitializer, "\t");
+          _builder.append(",");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* attributes */");
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _generateAttributeInit = this.attrInitGenAddon.generateAttributeInit(ai, this._roomHelpers.getAllAttributes(ai.getActorClass()));
+      _builder.append(_generateAttributeInit, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* state and history are initialized in init function */");
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genPeerPortArrays(final Root root, final ActorInstance ai) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<InterfaceItemInstance, Boolean> _function = (InterfaceItemInstance e) -> {
+        return Boolean.valueOf((e.isSimple() && (e instanceof PortInstance)));
+      };
+      final Function1<InterfaceItemInstance, PortInstance> _function_1 = (InterfaceItemInstance inst) -> {
+        return ((PortInstance) inst);
+      };
+      final Iterable<PortInstance> simplePorts = IterableExtensions.<InterfaceItemInstance, PortInstance>map(IterableExtensions.<InterfaceItemInstance>filter(ai.getOrderedIfItemInstances(), _function), _function_1);
+      final Function1<PortInstance, Boolean> _function_2 = (PortInstance p) -> {
+        return Boolean.valueOf((p.getPort().isConjugated() && Objects.equal(p.getProtocol().getCommType(), CommunicationType.DATA_DRIVEN)));
+      };
+      final Iterable<PortInstance> sendPorts = IterableExtensions.<PortInstance>filter(simplePorts, _function_2);
+      final Function1<PortInstance, Boolean> _function_3 = (PortInstance p) -> {
+        final Function1<Message, Boolean> _function_4 = (Message m) -> {
+          return Boolean.valueOf((this._typeHelpers.isEnumeration(m.getData().getRefType().getType()) || this._typeHelpers.isBoolean(m.getData().getRefType().getType())));
+        };
+        boolean _isEmpty = IterableExtensions.isEmpty(IterableExtensions.<Message>filter(this._roomHelpers.getOutgoing(p.getPort()), _function_4));
+        return Boolean.valueOf((!_isEmpty));
+      };
+      final Iterable<PortInstance> loggedPorts = IterableExtensions.<PortInstance>filter(sendPorts, _function_3);
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _isEmpty = IterableExtensions.isEmpty(loggedPorts);
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+          _builder.newLine();
+          {
+            for(final PortInstance pi : loggedPorts) {
+              _builder.append("static const char* ");
+              String _pathName = this._roomExtensions.getPathName(pi.getPath());
+              _builder.append(_pathName);
+              _builder.append("_peers[");
+              int _size = pi.getPeers().size();
+              int _plus = (_size + 1);
+              _builder.append(_plus);
+              _builder.append("] = {");
+              _builder.newLineIfNotEmpty();
+              {
+                EList<InterfaceItemInstance> _peers = pi.getPeers();
+                for(final InterfaceItemInstance peer : _peers) {
+                  _builder.append("\t");
+                  _builder.append("\"");
+                  EObject _eContainer = peer.eContainer();
+                  String _path = ((ActorInstance) _eContainer).getPath();
+                  _builder.append(_path, "\t");
+                  _builder.append("\",");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("NULL");
+              _builder.newLine();
+              _builder.append("};");
+              _builder.newLine();
+            }
+          }
+          _builder.append("#endif");
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String genPortInitializer(final Root root, final ActorInstance ai, final InterfaceItemInstance pi) {
+    String _xblockexpression = null;
+    {
+      int _xifexpression = (int) 0;
+      boolean _isEmpty = pi.getPeers().isEmpty();
+      if (_isEmpty) {
+        _xifexpression = 0;
+      } else {
+        _xifexpression = pi.getPeers().get(0).getObjId();
+      }
+      final int objId = _xifexpression;
+      int _xifexpression_1 = (int) 0;
+      boolean _isEmpty_1 = pi.getPeers().isEmpty();
+      if (_isEmpty_1) {
+        _xifexpression_1 = 0;
+      } else {
+        _xifexpression_1 = pi.getPeers().get(0).getPeers().indexOf(pi);
+      }
+      final int idx = _xifexpression_1;
+      String _xifexpression_2 = null;
+      boolean _isEmpty_2 = pi.getPeers().isEmpty();
+      if (_isEmpty_2) {
+        _xifexpression_2 = "NULL";
+      } else {
+        EObject _eContainer = pi.getPeers().get(0).eContainer();
+        String _name = ETMapUtil.getMappedThread(((ActorInstance) _eContainer)).getThread().getName();
+        _xifexpression_2 = ("&msgService_" + _name);
+      }
+      final String msgSvc = _xifexpression_2;
+      String myInst = "";
+      String peerInst = "";
+      boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+      if (_isGenerateMSCInstrumentation) {
+        EObject _eContainer_1 = pi.eContainer();
+        String _path = ((ActorInstance) _eContainer_1).getPath();
+        String _plus = ("\n#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE\n,\"" + _path);
+        String _plus_1 = (_plus + "\",");
+        myInst = _plus_1;
+        String _xifexpression_3 = null;
+        boolean _isEmpty_3 = pi.getPeers().isEmpty();
+        boolean _not = (!_isEmpty_3);
+        if (_not) {
+          EObject _eContainer_2 = pi.getPeers().get(0).eContainer();
+          String _path_1 = ((ActorInstance) _eContainer_2).getPath();
+          String _plus_2 = ("\"" + _path_1);
+          _xifexpression_3 = (_plus_2 + "\"\n#endif\n");
+        } else {
+          _xifexpression_3 = "\n#endif\n";
+        }
+        peerInst = _xifexpression_3;
+      }
+      String _interfaceItemInstanceData = this.getInterfaceItemInstanceData(pi);
+      String _plus_3 = ("{" + _interfaceItemInstanceData);
+      String _plus_4 = (_plus_3 + ", ");
+      String _plus_5 = (_plus_4 + msgSvc);
+      String _plus_6 = (_plus_5 + ", ");
+      String _plus_7 = (_plus_6 + Integer.valueOf((objId + idx)));
+      String _plus_8 = (_plus_7 + "+BASE_ADDRESS, ");
+      int _interfaceItemLocalId = root.getExpandedActorClass(ai).getInterfaceItemLocalId(pi.getInterfaceItem());
+      int _plus_9 = (_interfaceItemLocalId + 1);
+      String _plus_10 = (_plus_8 + Integer.valueOf(_plus_9));
+      String _plus_11 = (_plus_10 + myInst);
+      String _plus_12 = (_plus_11 + peerInst);
+      String _plus_13 = (_plus_12 + "} /* Port ");
+      String _name_1 = pi.getName();
+      String _plus_14 = (_plus_13 + _name_1);
+      _xblockexpression = (_plus_14 + " */");
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genSendPortInitializer(final InterfaceItemInstance pi) {
+    CharSequence _xblockexpression = null;
+    {
+      GeneralProtocolClass _protocol = ((PortInstance) pi).getPort().getProtocol();
+      final ProtocolClass pc = ((ProtocolClass) _protocol);
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      Iterable<Message> messages = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      final Function1<Message, Boolean> _function_1 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isEnumeration(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> enumMsgs = IterableExtensions.<Message>filter(messages, _function_1);
+      final Function1<Message, Boolean> _function_2 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isBoolean(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> boolMsgs = IterableExtensions.<Message>filter(messages, _function_2);
+      final boolean usesMSC = (Main.getSettings().isGenerateMSCInstrumentation() && (!(IterableExtensions.isEmpty(enumMsgs) && IterableExtensions.isEmpty(boolMsgs))));
+      EObject _eContainer = pi.eContainer();
+      final String instName = ((ActorInstance) _eContainer).getPath();
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("{");
+      _builder.newLine();
+      {
+        EList<Message> _incomingMessages = pc.getIncomingMessages();
+        boolean _hasElements = false;
+        for(final Message m : _incomingMessages) {
+          if (!_hasElements) {
+            _hasElements = true;
+          } else {
+            _builder.appendImmediate(",", "\t");
+          }
+          _builder.append("\t");
+          String _defaultValue = this._cExtensions.defaultValue(m.getData().getRefType().getType());
+          _builder.append(_defaultValue, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        if (usesMSC) {
+          _builder.append("\t");
+          _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append(", \"");
+          _builder.append(instName, "\t\t");
+          _builder.append("\",");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t");
+          String _pathName = this._roomExtensions.getPathName(pi.getPath());
+          _builder.append(_pathName, "\t\t");
+          _builder.append("_peers");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("#endif");
+          _builder.newLine();
+        }
+      }
+      _builder.append("} /* send port ");
+      String _name = pi.getName();
+      _builder.append(_name);
+      _builder.append(" */");
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getInterfaceItemInstanceData(final InterfaceItemInstance pi) {
+    PortClass _portClass = this._roomExtensions.getPortClass(pi.getProtocol(), this._roomExtensions.isConjugated(pi));
+    boolean _equals = Objects.equal(_portClass, null);
+    if (_equals) {
+      return "NULL";
+    }
+    boolean _isEmpty = this._roomExtensions.getPortClass(pi.getProtocol(), this._roomExtensions.isConjugated(pi)).getAttributes().isEmpty();
+    if (_isEmpty) {
+      return "NULL";
+    } else {
+      String _pathName = this._roomExtensions.getPathName(pi.getPath());
+      String _plus = ("&" + _pathName);
+      return (_plus + "_var");
+    }
+  }
+  
+  private String genRecvPortInitializer(final Root root, final ActorInstance ai, final InterfaceItemInstance pi) {
+    String _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      Iterable<Message> sentMsgs = IterableExtensions.<Message>filter(this._roomHelpers.getIncoming(pi.getInterfaceItem()), _function);
+      final Function1<Message, Boolean> _function_1 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isEnumeration(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> enumMsgs = IterableExtensions.<Message>filter(sentMsgs, _function_1);
+      final Function1<Message, Boolean> _function_2 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isBoolean(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> boolMsgs = IterableExtensions.<Message>filter(sentMsgs, _function_2);
+      final boolean usesMSC = (Main.getSettings().isGenerateMSCInstrumentation() && (!(IterableExtensions.isEmpty(enumMsgs) && IterableExtensions.isEmpty(boolMsgs))));
+      String enumVal = "";
+      if (usesMSC) {
+        String _path = ai.getPath();
+        String _plus = ("\n, \"" + _path);
+        String _plus_1 = (_plus + "\"");
+        enumVal = _plus_1;
+        for (final Message msg : enumMsgs) {
+          String _defaultValue = this._cExtensions.defaultValue(msg.getData().getRefType().getType());
+          String _plus_2 = ((enumVal + "\n, ") + _defaultValue);
+          enumVal = _plus_2;
+        }
+        for (final Message msg_1 : boolMsgs) {
+          String _defaultValue_1 = this._cExtensions.defaultValue(msg_1.getData().getRefType().getType());
+          String _plus_3 = ((enumVal + "\n, ") + _defaultValue_1);
+          enumVal = _plus_3;
+        }
+        enumVal = (("\n#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE" + enumVal) + "\n#endif\n");
+      }
+      boolean _isEmpty = pi.getPeers().isEmpty();
+      if (_isEmpty) {
+        return (("{NULL" + enumVal) + "}");
+      }
+      InterfaceItemInstance peer = pi.getPeers().get(0);
+      EObject _eContainer = pi.getPeers().get(0).eContainer();
+      ActorInstance peerInst = ((ActorInstance) _eContainer);
+      String instName = this._roomExtensions.getPathName(peerInst.getPath());
+      String _name = peer.getName();
+      String _plus_4 = ((("{&" + instName) + ".") + _name);
+      String _plus_5 = (_plus_4 + enumVal);
+      _xblockexpression = (_plus_5 + "}");
+    }
+    return _xblockexpression;
+  }
+  
+  private String genReplSubPortInitializers(final Root root, final ActorInstance ai, final InterfaceItemInstance pi) {
+    String result = "";
+    String _xifexpression = null;
+    boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+    if (_isGenerateMSCInstrumentation) {
+      EObject _eContainer = pi.eContainer();
+      String _path = ((ActorInstance) _eContainer).getPath();
+      String _plus = ("\n#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE\n,\"" + _path);
+      _xifexpression = (_plus + "\"\n");
+    } else {
+      _xifexpression = "";
+    }
+    final String myInst = _xifexpression;
+    EList<InterfaceItemInstance> _peers = pi.getPeers();
+    for (final InterfaceItemInstance p : _peers) {
+      {
+        final int idx = pi.getPeers().indexOf(p);
+        String _xifexpression_1 = null;
+        int _size = pi.getPeers().size();
+        int _minus = (_size - 1);
+        boolean _lessThan = (idx < _minus);
+        if (_lessThan) {
+          _xifexpression_1 = ",";
+        } else {
+          _xifexpression_1 = "";
+        }
+        final String comma = _xifexpression_1;
+        EObject _eContainer_1 = p.eContainer();
+        final String thread = ETMapUtil.getMappedThread(((ActorInstance) _eContainer_1)).getThread().getName();
+        String iiiD = this.getInterfaceItemInstanceData(pi);
+        String _xifexpression_2 = null;
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          EObject _eContainer_2 = p.eContainer();
+          String _path_1 = ((ActorInstance) _eContainer_2).getPath();
+          String _plus_1 = (",\"" + _path_1);
+          _xifexpression_2 = (_plus_1 + "\"\n#endif\n");
+        } else {
+          _xifexpression_2 = "";
+        }
+        final String peerInst = _xifexpression_2;
+        String _xifexpression_3 = null;
+        boolean _equals = iiiD.equals("NULL");
+        if (_equals) {
+          _xifexpression_3 = (iiiD + ",");
+        } else {
+          _xifexpression_3 = (((iiiD + "[") + Integer.valueOf(idx)) + "],");
+        }
+        iiiD = _xifexpression_3;
+        int _objId = p.getObjId();
+        String _plus_2 = ((((((result + 
+          "{{") + iiiD) + "&msgService_") + thread) + ", ") + Integer.valueOf(_objId));
+        String _plus_3 = (_plus_2 + "+BASE_ADDRESS, ");
+        int _interfaceItemLocalId = root.getExpandedActorClass(ai).getInterfaceItemLocalId(pi.getInterfaceItem());
+        int _plus_4 = (_interfaceItemLocalId + 1);
+        String _plus_5 = (_plus_3 + Integer.valueOf(_plus_4));
+        String _plus_6 = (_plus_5 + myInst);
+        String _plus_7 = (_plus_6 + peerInst);
+        String _plus_8 = (_plus_7 + "},");
+        String _plus_9 = (_plus_8 + Integer.valueOf(idx));
+        String _plus_10 = (_plus_9 + "}");
+        String _plus_11 = (_plus_10 + comma);
+        String _plus_12 = (_plus_11 + " /* Repl Sub Port ");
+        String _name = pi.getName();
+        String _plus_13 = (_plus_12 + _name);
+        String _plus_14 = (_plus_13 + " idx +");
+        String _plus_15 = (_plus_14 + Integer.valueOf(idx));
+        String _plus_16 = (_plus_15 + "*/\n");
+        result = _plus_16;
+      }
+    }
+    return result;
+  }
+  
+  private CharSequence generateDispatcherFile(final Root root, final SubSystemInstance ssi, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final NodeRef nr = ETMapUtil.getNodeRef(ssi);
+      final boolean logData = (Main.getSettings().isGenerateDataInstrumentation() && this._roomHelpers.isAnnotationPresent(ssi.getSubSystemClass().getAnnotations(), "DataLogging"));
+      ArrayList<PortInstance> _xifexpression = null;
+      if (logData) {
+        _xifexpression = this.loggedPorts(ssi);
+      } else {
+        _xifexpression = CollectionLiterals.<PortInstance>newArrayList();
+      }
+      final ArrayList<PortInstance> loggedPorts = _xifexpression;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Dispatcher File of Node ");
+      String _name = nr.getName();
+      _builder.append(_name, " ");
+      _builder.append(" with SubSystem ");
+      String _name_1 = ssi.getName();
+      _builder.append(_name_1, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("* contains a generated message dispatcher (receiveMessage) for each MessageService (Thread)");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"messaging/etMessageReceiver.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etLogger.h\"");
+      _builder.newLine();
+      _builder.append("#include \"debugging/etMSCLogger.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Boolean> _function = (PhysicalThread t) -> {
+          return Boolean.valueOf(usedThreads.contains(t));
+        };
+        Iterable<PhysicalThread> _filter = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function);
+        boolean _hasElements = false;
+        for(final PhysicalThread thread : _filter) {
+          if (!_hasElements) {
+            _hasElements = true;
+          } else {
+            _builder.appendImmediate("\n", "");
+          }
+          final Function1<ActorInstance, Boolean> _function_1 = (ActorInstance ai) -> {
+            PhysicalThread _thread = ETMapUtil.getMappedThread(ai).getThread();
+            return Boolean.valueOf(Objects.equal(_thread, thread));
+          };
+          final Iterable<ActorInstance> instancesOnThread = IterableExtensions.<ActorInstance>filter(ssi.getAllContainedInstances(), _function_1);
+          _builder.newLineIfNotEmpty();
+          final Function1<ActorInstance, Boolean> _function_2 = (ActorInstance ai) -> {
+            return Boolean.valueOf((Objects.equal(ai.getActorClass().getCommType(), ComponentCommunicationType.EVENT_DRIVEN) || Objects.equal(ai.getActorClass().getCommType(), ComponentCommunicationType.ASYNCHRONOUS)));
+          };
+          final Iterable<ActorInstance> dispatchedInstances = IterableExtensions.<ActorInstance>filter(instancesOnThread, _function_2);
+          _builder.newLineIfNotEmpty();
+          final Function1<ActorInstance, Boolean> _function_3 = (ActorInstance ai) -> {
+            return Boolean.valueOf((Objects.equal(ai.getActorClass().getCommType(), ComponentCommunicationType.DATA_DRIVEN) || Objects.equal(ai.getActorClass().getCommType(), ComponentCommunicationType.ASYNCHRONOUS)));
+          };
+          final Iterable<ActorInstance> executedInstances = IterableExtensions.<ActorInstance>filter(instancesOnThread, _function_3);
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+          {
+            int _size = IterableExtensions.size(executedInstances);
+            boolean _greaterThan = (_size > 0);
+            if (_greaterThan) {
+              _builder.append("/**");
+              _builder.newLine();
+              _builder.append(" ");
+              _builder.append("* generated execute function for all cyclic execute calls for the async or datadriven actor instances of thread \"");
+              String _name_2 = thread.getName();
+              _builder.append(_name_2, " ");
+              _builder.append("\"");
+              _builder.newLineIfNotEmpty();
+              _builder.append(" ");
+              _builder.append("*/");
+              _builder.newLine();
+              _builder.append("static void MsgDispatcher_");
+              String _name_3 = thread.getName();
+              _builder.append(_name_3);
+              _builder.append("_poll(void){");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"MsgDispatcher_");
+              String _name_4 = thread.getName();
+              _builder.append(_name_4, "\t");
+              _builder.append("\", \"execute\")");
+              _builder.newLineIfNotEmpty();
+              {
+                for(final ActorInstance ai : executedInstances) {
+                  _builder.append("\t");
+                  String _name_5 = ai.getActorClass().getName();
+                  _builder.append(_name_5, "\t");
+                  _builder.append("_execute((void*)&");
+                  String _pathName = this._roomExtensions.getPathName(ai.getPath());
+                  _builder.append(_pathName, "\t");
+                  _builder.append(");");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+              _builder.newLine();
+              _builder.append("}");
+              _builder.newLine();
+              {
+                if (logData) {
+                  _builder.append("static void MsgDispatcher_");
+                  String _name_6 = thread.getName();
+                  _builder.append(_name_6);
+                  _builder.append("_logDataHeaders(void){");
+                  _builder.newLineIfNotEmpty();
+                  {
+                    for(final PortInstance pi : loggedPorts) {
+                      _builder.append("\t");
+                      _builder.append("ET_DATA_LOGGER_LOG_STRING(\"");
+                      String _path = pi.getPath();
+                      _builder.append(_path, "\t");
+                      _builder.append("\")");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                  _builder.append("}");
+                  _builder.newLine();
+                  _builder.append("static void MsgDispatcher_");
+                  String _name_7 = thread.getName();
+                  _builder.append(_name_7);
+                  _builder.append("_logData(void){");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("ET_DATA_LOGGER_NEW_ROW");
+                  _builder.newLine();
+                  {
+                    for(final PortInstance pi_1 : loggedPorts) {
+                      _builder.append("\t");
+                      String _createLoggerCall = this.createLoggerCall(pi_1);
+                      _builder.append(_createLoggerCall, "\t");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                  _builder.append("}");
+                  _builder.newLine();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("/**");
+          _builder.newLine();
+          _builder.append(" ");
+          _builder.append("* generated dispatch function for all messages for the thread \"");
+          String _name_8 = thread.getName();
+          _builder.append(_name_8, " ");
+          _builder.append("\"");
+          _builder.newLineIfNotEmpty();
+          _builder.append(" ");
+          _builder.append("*/");
+          _builder.newLine();
+          _builder.append("static etBool MsgDispatcher_");
+          String _name_9 = thread.getName();
+          _builder.append(_name_9);
+          _builder.append("_receiveMessage(const etMessage* msg){");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"MsgDispatcher_");
+          String _name_10 = thread.getName();
+          _builder.append(_name_10, "\t");
+          _builder.append("\", \"receiveMessage\")");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("switch(msg->address){");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("case MESSAGESERVICE_ADDRESS:");
+          _builder.newLine();
+          {
+            boolean _isEmpty = IterableExtensions.isEmpty(executedInstances);
+            boolean _not = (!_isEmpty);
+            if (_not) {
+              _builder.append("\t\t\t");
+              _builder.append("if (msg->evtID == etSystemProtocol_IN_poll) {");
+              _builder.newLine();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("MsgDispatcher_");
+              String _name_11 = thread.getName();
+              _builder.append(_name_11, "\t\t\t\t");
+              _builder.append("_poll();");
+              _builder.newLineIfNotEmpty();
+              {
+                if (logData) {
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("MsgDispatcher_");
+                  String _name_12 = thread.getName();
+                  _builder.append(_name_12, "\t\t\t\t");
+                  _builder.append("_logData();");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t\t\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t\t\t");
+              _builder.append("else");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t\t\t");
+          _builder.append("if (msg->evtID == etSystemProtocol_IN_terminate)");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("return ET_FALSE;");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          {
+            for(final ActorInstance ai_1 : dispatchedInstances) {
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("/* interface items of ");
+              String _path_1 = ai_1.getPath();
+              _builder.append(_path_1, "\t\t");
+              _builder.append(" */");
+              _builder.newLineIfNotEmpty();
+              {
+                final Function1<InterfaceItemInstance, Boolean> _function_4 = (InterfaceItemInstance p) -> {
+                  CommunicationType _commType = p.getProtocol().getCommType();
+                  return Boolean.valueOf(Objects.equal(_commType, CommunicationType.EVENT_DRIVEN));
+                };
+                Iterable<InterfaceItemInstance> _filter_1 = IterableExtensions.<InterfaceItemInstance>filter(ai_1.getOrderedIfItemInstances(), _function_4);
+                for(final InterfaceItemInstance pi_2 : _filter_1) {
+                  {
+                    boolean _isReplicated = pi_2.isReplicated();
+                    if (_isReplicated) {
+                      {
+                        EList<InterfaceItemInstance> _peers = pi_2.getPeers();
+                        for(final InterfaceItemInstance peer : _peers) {
+                          _builder.append("\t\t");
+                          _builder.append("case ");
+                          int _objId = pi_2.getObjId();
+                          int _indexOf = pi_2.getPeers().indexOf(peer);
+                          int _plus = (_objId + _indexOf);
+                          _builder.append(_plus, "\t\t");
+                          _builder.append("+BASE_ADDRESS:");
+                          _builder.newLineIfNotEmpty();
+                          {
+                            boolean _handlesReceive = this._roomExtensions.handlesReceive(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                            if (_handlesReceive) {
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("switch (msg->evtID){");
+                              _builder.newLine();
+                              {
+                                List<MessageHandler> _receiveHandlers = this._roomExtensions.getReceiveHandlers(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                                for(final MessageHandler h : _receiveHandlers) {
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  _builder.append("case ");
+                                  String _name_13 = pi_2.getProtocol().getName();
+                                  _builder.append(_name_13, "\t\t\t\t");
+                                  _builder.append("_");
+                                  String _codeName = this._roomExtensions.getCodeName(h.getMsg());
+                                  _builder.append(_codeName, "\t\t\t\t");
+                                  _builder.append(":");
+                                  _builder.newLineIfNotEmpty();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  String _portClassName = this._roomExtensions.getPortClassName(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                                  _builder.append(_portClassName, "\t\t\t\t\t");
+                                  _builder.append("_");
+                                  String _name_14 = h.getMsg().getName();
+                                  _builder.append(_name_14, "\t\t\t\t\t");
+                                  _builder.append("_receiveHandler((etPort *)&");
+                                  String _pathName_1 = this._roomExtensions.getPathName(ai_1.getPath());
+                                  _builder.append(_pathName_1, "\t\t\t\t\t");
+                                  _builder.append("_const.");
+                                  String _name_15 = pi_2.getName();
+                                  _builder.append(_name_15, "\t\t\t\t\t");
+                                  _builder.append(".ports[");
+                                  int _indexOf_1 = pi_2.getPeers().indexOf(peer);
+                                  _builder.append(_indexOf_1, "\t\t\t\t\t");
+                                  _builder.append("],msg,(void*)&");
+                                  String _pathName_2 = this._roomExtensions.getPathName(ai_1.getPath());
+                                  _builder.append(_pathName_2, "\t\t\t\t\t");
+                                  _builder.append(",");
+                                  String _name_16 = ai_1.getActorClass().getName();
+                                  _builder.append(_name_16, "\t\t\t\t\t");
+                                  _builder.append("_receiveMessage);");
+                                  _builder.newLineIfNotEmpty();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  _builder.append("break;");
+                                  _builder.newLine();
+                                }
+                              }
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("default: ");
+                              String _name_17 = ai_1.getActorClass().getName();
+                              _builder.append(_name_17, "\t\t\t\t");
+                              _builder.append("_receiveMessage((void*)&");
+                              String _pathName_3 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_3, "\t\t\t\t");
+                              _builder.append(",(etPort*)&");
+                              String _pathName_4 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_4, "\t\t\t\t");
+                              _builder.append("_const.");
+                              String _name_18 = pi_2.getName();
+                              _builder.append(_name_18, "\t\t\t\t");
+                              _builder.append(".ports[");
+                              int _indexOf_2 = pi_2.getPeers().indexOf(peer);
+                              _builder.append(_indexOf_2, "\t\t\t\t");
+                              _builder.append("], msg);");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t\t");
+                              _builder.append("break;");
+                              _builder.newLine();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("}");
+                              _builder.newLine();
+                            } else {
+                              {
+                                boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+                                if (_isGenerateMSCInstrumentation) {
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("ET_MSC_LOGGER_ASYNC_IN(");
+                                  _builder.newLine();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  String _pathName_5 = this._roomExtensions.getPathName(ai_1.getPath());
+                                  _builder.append(_pathName_5, "\t\t\t\t");
+                                  _builder.append("_const.");
+                                  String _name_19 = pi_2.getName();
+                                  _builder.append(_name_19, "\t\t\t\t");
+                                  _builder.append(".ports[");
+                                  int _indexOf_3 = pi_2.getPeers().indexOf(peer);
+                                  _builder.append(_indexOf_3, "\t\t\t\t");
+                                  _builder.append("].port.peerInstName,");
+                                  _builder.newLineIfNotEmpty();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  String _name_20 = pi_2.getProtocol().getName();
+                                  _builder.append(_name_20, "\t\t\t\t");
+                                  _builder.append("_getMessageString(msg->evtID),");
+                                  _builder.newLineIfNotEmpty();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  String _pathName_6 = this._roomExtensions.getPathName(ai_1.getPath());
+                                  _builder.append(_pathName_6, "\t\t\t\t");
+                                  _builder.append("_const.");
+                                  String _name_21 = pi_2.getName();
+                                  _builder.append(_name_21, "\t\t\t\t");
+                                  _builder.append(".ports[");
+                                  int _indexOf_4 = pi_2.getPeers().indexOf(peer);
+                                  _builder.append(_indexOf_4, "\t\t\t\t");
+                                  _builder.append("].port.myInstName");
+                                  _builder.newLineIfNotEmpty();
+                                  _builder.append("\t\t");
+                                  _builder.append("\t");
+                                  _builder.append("\t");
+                                  _builder.append(")");
+                                  _builder.newLine();
+                                }
+                              }
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              String _name_22 = ai_1.getActorClass().getName();
+                              _builder.append(_name_22, "\t\t\t");
+                              _builder.append("_receiveMessage((void*)&");
+                              String _pathName_7 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_7, "\t\t\t");
+                              _builder.append(",&");
+                              String _pathName_8 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_8, "\t\t\t");
+                              _builder.append("_const.");
+                              String _name_23 = pi_2.getName();
+                              _builder.append(_name_23, "\t\t\t");
+                              _builder.append(".ports[");
+                              int _indexOf_5 = pi_2.getPeers().indexOf(peer);
+                              _builder.append(_indexOf_5, "\t\t\t");
+                              _builder.append("].port, msg);");
+                              _builder.newLineIfNotEmpty();
+                            }
+                          }
+                          _builder.append("\t\t");
+                          _builder.append("break;");
+                          _builder.newLine();
+                        }
+                      }
+                    } else {
+                      _builder.append("\t\t");
+                      _builder.append("case ");
+                      int _objId_1 = pi_2.getObjId();
+                      _builder.append(_objId_1, "\t\t");
+                      _builder.append("+BASE_ADDRESS:");
+                      _builder.newLineIfNotEmpty();
+                      {
+                        boolean _handlesReceive_1 = this._roomExtensions.handlesReceive(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                        if (_handlesReceive_1) {
+                          _builder.append("\t\t");
+                          _builder.append("\t");
+                          _builder.append("switch (msg->evtID){");
+                          _builder.newLine();
+                          {
+                            List<MessageHandler> _receiveHandlers_1 = this._roomExtensions.getReceiveHandlers(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                            for(final MessageHandler h_1 : _receiveHandlers_1) {
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("case ");
+                              String _name_24 = pi_2.getProtocol().getName();
+                              _builder.append(_name_24, "\t\t\t\t");
+                              _builder.append("_");
+                              String _codeName_1 = this._roomExtensions.getCodeName(h_1.getMsg());
+                              _builder.append(_codeName_1, "\t\t\t\t");
+                              _builder.append(":");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              String _portClassName_1 = this._roomExtensions.getPortClassName(pi_2.getProtocol(), this._roomExtensions.isConjugated(pi_2));
+                              _builder.append(_portClassName_1, "\t\t\t\t\t");
+                              _builder.append("_");
+                              String _name_25 = h_1.getMsg().getName();
+                              _builder.append(_name_25, "\t\t\t\t\t");
+                              _builder.append("_receiveHandler((etPort *)&");
+                              String _pathName_9 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_9, "\t\t\t\t\t");
+                              _builder.append("_const.");
+                              String _name_26 = pi_2.getName();
+                              _builder.append(_name_26, "\t\t\t\t\t");
+                              _builder.append(",msg,(void*)&");
+                              String _pathName_10 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_10, "\t\t\t\t\t");
+                              _builder.append(",");
+                              String _name_27 = ai_1.getActorClass().getName();
+                              _builder.append(_name_27, "\t\t\t\t\t");
+                              _builder.append("_receiveMessage);");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("break;");
+                              _builder.newLine();
+                            }
+                          }
+                          _builder.append("\t\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("default: ");
+                          String _name_28 = ai_1.getActorClass().getName();
+                          _builder.append(_name_28, "\t\t\t\t");
+                          _builder.append("_receiveMessage((void*)&");
+                          String _pathName_11 = this._roomExtensions.getPathName(ai_1.getPath());
+                          _builder.append(_pathName_11, "\t\t\t\t");
+                          _builder.append(",(etPort*)&");
+                          String _pathName_12 = this._roomExtensions.getPathName(ai_1.getPath());
+                          _builder.append(_pathName_12, "\t\t\t\t");
+                          _builder.append("_const.");
+                          String _name_29 = pi_2.getName();
+                          _builder.append(_name_29, "\t\t\t\t");
+                          _builder.append(", msg);");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t\t");
+                          _builder.append("\t");
+                          _builder.append("\t\t");
+                          _builder.append("break;");
+                          _builder.newLine();
+                          _builder.append("\t\t");
+                          _builder.append("\t");
+                          _builder.append("}");
+                          _builder.newLine();
+                        } else {
+                          {
+                            boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+                            if (_isGenerateMSCInstrumentation_1) {
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("ET_MSC_LOGGER_ASYNC_IN(");
+                              _builder.newLine();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("((etPort*)&");
+                              String _pathName_13 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_13, "\t\t\t\t");
+                              _builder.append("_const.");
+                              String _name_30 = pi_2.getName();
+                              _builder.append(_name_30, "\t\t\t\t");
+                              _builder.append(")->peerInstName,");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              String _name_31 = pi_2.getProtocol().getName();
+                              _builder.append(_name_31, "\t\t\t\t");
+                              _builder.append("_getMessageString(msg->evtID),");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append("((etPort*)&");
+                              String _pathName_14 = this._roomExtensions.getPathName(ai_1.getPath());
+                              _builder.append(_pathName_14, "\t\t\t\t");
+                              _builder.append("_const.");
+                              String _name_32 = pi_2.getName();
+                              _builder.append(_name_32, "\t\t\t\t");
+                              _builder.append(")->myInstName");
+                              _builder.newLineIfNotEmpty();
+                              _builder.append("\t\t");
+                              _builder.append("\t");
+                              _builder.append("\t");
+                              _builder.append(")");
+                              _builder.newLine();
+                            }
+                          }
+                          _builder.append("\t\t");
+                          _builder.append("\t");
+                          String _name_33 = ai_1.getActorClass().getName();
+                          _builder.append(_name_33, "\t\t\t");
+                          _builder.append("_receiveMessage((void*)&");
+                          String _pathName_15 = this._roomExtensions.getPathName(ai_1.getPath());
+                          _builder.append(_pathName_15, "\t\t\t");
+                          _builder.append(",(etPort*)&");
+                          String _pathName_16 = this._roomExtensions.getPathName(ai_1.getPath());
+                          _builder.append(_pathName_16, "\t\t\t");
+                          _builder.append("_const.");
+                          String _name_34 = pi_2.getName();
+                          _builder.append(_name_34, "\t\t\t");
+                          _builder.append(", msg);");
+                          _builder.newLineIfNotEmpty();
+                        }
+                      }
+                      _builder.append("\t\t");
+                      _builder.append("\t");
+                      _builder.append("break;");
+                      _builder.newLine();
+                    }
+                  }
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("default:");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("etLogger_logErrorF(\"MessageService_");
+          String _name_35 = thread.getName();
+          _builder.append(_name_35, "\t\t\t");
+          _builder.append("_receiveMessage: address %d does not exist \", msg->address);");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("return ET_TRUE;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String createLoggerCall(final PortInstance pi) {
+    String _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        return Boolean.valueOf(((!Objects.equal(m.getData(), null)) && this._typeHelpers.isEnumerationOrPrimitive(m.getData().getRefType().getType())));
+      };
+      final Message msg = ((Message[])Conversions.unwrapArray(IterableExtensions.<Message>filter(pi.getProtocol().getIncomingMessages(), _function), Message.class))[0];
+      EObject _eContainer = pi.eContainer();
+      final ActorInstance ai = ((ActorInstance) _eContainer);
+      String _pathName = this._roomExtensions.getPathName(ai.getPath());
+      String _plus = (_pathName + ".");
+      String _name = pi.getName();
+      String _plus_1 = (_plus + _name);
+      String _plus_2 = (_plus_1 + ".");
+      String _name_1 = msg.getName();
+      final String data = (_plus_2 + _name_1);
+      LiteralType _xifexpression = null;
+      DataType _type = msg.getData().getRefType().getType();
+      if ((_type instanceof EnumerationType)) {
+        _xifexpression = LiteralType.INT;
+      } else {
+        DataType _type_1 = msg.getData().getRefType().getType();
+        _xifexpression = ((PrimitiveType) _type_1).getType();
+      }
+      final LiteralType type = _xifexpression;
+      String _switchResult = null;
+      if (type != null) {
+        switch (type) {
+          case BOOL:
+            _switchResult = (("ET_DATA_LOGGER_LOG_BOOL((int)" + data) + ")");
+            break;
+          case CHAR:
+            _switchResult = (("ET_DATA_LOGGER_LOG_INT((int)" + data) + ")");
+            break;
+          case INT:
+            _switchResult = (("ET_DATA_LOGGER_LOG_INT((int)" + data) + ")");
+            break;
+          case REAL:
+            _switchResult = (("ET_DATA_LOGGER_LOG_DOUBLE((double)" + data) + ")");
+            break;
+          default:
+            _switchResult = "internal error: unknown primitive type";
+            break;
+        }
+      } else {
+        _switchResult = "internal error: unknown primitive type";
+      }
+      _xblockexpression = _switchResult;
+    }
+    return _xblockexpression;
+  }
+  
+  private ArrayList<PortInstance> loggedPorts(final SubSystemInstance ssi) {
+    final ArrayList<PortInstance> result = CollectionLiterals.<PortInstance>newArrayList();
+    boolean _isAnnotationPresent = this._roomHelpers.isAnnotationPresent(ssi.getSubSystemClass().getAnnotations(), "DataLogging");
+    if (_isAnnotationPresent) {
+      this.logger.logInfo("Data Logging is configured by annotation");
+      final String filters = this._roomHelpers.getAttribute(ssi.getSubSystemClass().getAnnotations(), "DataLogging", "pathlist");
+      final String[] filterList = filters.split(",");
+      for (final String filter : filterList) {
+        this.logger.logInfo(("  filter: " + filter));
+      }
+      final ArrayList<String> notLogged = CollectionLiterals.<String>newArrayList();
+      this.logger.logInfo("  logged ports:");
+      TreeIterator<EObject> iter = ssi.eAllContents();
+      while (iter.hasNext()) {
+        {
+          final EObject obj = iter.next();
+          if ((obj instanceof PortInstance)) {
+            final PortInstance pi = ((PortInstance) obj);
+            boolean _isRelay = this._roomHelpers.isRelay(pi.getPort());
+            boolean _not = (!_isRelay);
+            if (_not) {
+              CommunicationType _commType = pi.getProtocol().getCommType();
+              boolean _equals = Objects.equal(_commType, CommunicationType.DATA_DRIVEN);
+              if (_equals) {
+                boolean _isConjugated = pi.getPort().isConjugated();
+                if (_isConjugated) {
+                  final String path = pi.getPath();
+                  boolean matched = false;
+                  boolean primitive = false;
+                  for (final String filter_1 : filterList) {
+                    boolean _matches = path.matches(filter_1);
+                    if (_matches) {
+                      matched = true;
+                      final Function1<Message, Boolean> _function = (Message m) -> {
+                        return Boolean.valueOf(((!Objects.equal(m.getData(), null)) && this._typeHelpers.isEnumerationOrPrimitive(m.getData().getRefType().getType())));
+                      };
+                      boolean _isEmpty = IterableExtensions.isEmpty(IterableExtensions.<Message>filter(pi.getProtocol().getIncomingMessages(), _function));
+                      boolean _not_1 = (!_isEmpty);
+                      if (_not_1) {
+                        result.add(pi);
+                        primitive = true;
+                        String _path = pi.getPath();
+                        String _plus = ("    data driven port " + _path);
+                        String _plus_1 = (_plus + " (matched ");
+                        String _plus_2 = (_plus_1 + filter_1);
+                        String _plus_3 = (_plus_2 + ")");
+                        this.logger.logInfo(_plus_3);
+                      }
+                    }
+                  }
+                  if ((!primitive)) {
+                    if (matched) {
+                      String _path_1 = pi.getPath();
+                      String _plus_4 = ("    data driven port " + _path_1);
+                      String _plus_5 = (_plus_4 + " (matched but contains no primitive data)");
+                      notLogged.add(_plus_5);
+                    } else {
+                      String _path_2 = pi.getPath();
+                      String _plus_6 = ("    data driven port " + _path_2);
+                      String _plus_7 = (_plus_6 + " (no match found)");
+                      notLogged.add(_plus_7);
+                    }
+                  }
+                } else {
+                  String _path_3 = pi.getPath();
+                  String _plus_8 = ("    data driven port " + _path_3);
+                  String _plus_9 = (_plus_8 + " (receive port)");
+                  notLogged.add(_plus_9);
+                }
+              }
+            }
+          }
+        }
+      }
+      this.logger.logInfo("  NOT logged ports:");
+      for (final String nl : notLogged) {
+        this.logger.logInfo(nl);
+      }
+    }
+    return result;
+  }
+  
+  private void checkDataPorts(final SubSystemInstance comp) {
+    final HashSet<String> found = new HashSet<String>();
+    EList<ActorInstance> _allContainedInstances = comp.getAllContainedInstances();
+    for (final ActorInstance ai : _allContainedInstances) {
+      {
+        final int thread = ai.getThreadId();
+        EList<InterfaceItemInstance> _orderedIfItemInstances = ai.getOrderedIfItemInstances();
+        for (final InterfaceItemInstance pi : _orderedIfItemInstances) {
+          CommunicationType _commType = pi.getProtocol().getCommType();
+          boolean _equals = Objects.equal(_commType, CommunicationType.DATA_DRIVEN);
+          if (_equals) {
+            EList<InterfaceItemInstance> _peers = pi.getPeers();
+            for (final InterfaceItemInstance peer : _peers) {
+              {
+                EObject _eContainer = peer.eContainer();
+                final ActorInstance peer_ai = ((ActorInstance) _eContainer);
+                final int peer_thread = peer_ai.getThreadId();
+                if ((thread != peer_thread)) {
+                  final String path = pi.getPath();
+                  final String ppath = peer.getPath();
+                  String _xifexpression = null;
+                  int _compareTo = path.compareTo(ppath);
+                  boolean _lessThan = (_compareTo < 0);
+                  if (_lessThan) {
+                    _xifexpression = ((path + " and ") + ppath);
+                  } else {
+                    _xifexpression = ((ppath + " and ") + path);
+                  }
+                  final String pair = _xifexpression;
+                  boolean _contains = found.contains(pair);
+                  boolean _not = (!_contains);
+                  if (_not) {
+                    found.add(pair);
+                    this.diagnostician.error((pair + ": data ports placed on different threads (not supported yet)"), 
+                      pi.getInterfaceItem(), pi.getInterfaceItem().eContainingFeature());
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.java
new file mode 100644
index 000000000..ffe24c515
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/ProtocolClassGen.java
@@ -0,0 +1,1428 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (changed for C code generator)
+ */
+package org.eclipse.etrice.generator.c.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.CommunicationType;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.EnumerationType;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageHandler;
+import org.eclipse.etrice.core.room.Operation;
+import org.eclipse.etrice.core.room.PortClass;
+import org.eclipse.etrice.core.room.PortOperation;
+import org.eclipse.etrice.core.room.ProtocolClass;
+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.generator.base.AbstractGenerator;
+import org.eclipse.etrice.generator.c.Main;
+import org.eclipse.etrice.generator.c.gen.CExtensions;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+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.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ProtocolClassGen extends GenericProtocolClassGenerator {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private CExtensions _cExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    EList<ProtocolClass> _protocolClasses = root.getProtocolClasses();
+    for (final ProtocolClass pc : _protocolClasses) {
+      {
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(pc);
+        String _path = this._roomExtensions.getPath(pc);
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(pc);
+        String _path_1 = this._roomExtensions.getPath(pc);
+        final String infopath = (_generationInfoPath + _path_1);
+        String file = this._cExtensions.getCHeaderFileName(pc);
+        this.fileIO.generateFile("generating ProtocolClass header", path, infopath, file, this.generateHeaderFile(root, pc));
+        file = this._cExtensions.getCUtilsFileName(pc);
+        this.fileIO.generateFile("generating ProtocolClass utils", path, infopath, file, this.generateUtilsFile(root, pc));
+        file = this._cExtensions.getCSourceFileName(pc);
+        this.fileIO.generateFile("generating ProtocolClass source", path, infopath, file, this.generateSourceFile(root, pc));
+      }
+    }
+  }
+  
+  private CharSequence generateHeaderFile(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Header File of ProtocolClass ");
+    String _name = pc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("* ");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(pc);
+    _builder.append(_generateIncludeGuardBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"etDatatypes.h\"");
+    _builder.newLine();
+    _builder.append("#include \"modelbase/etPort.h\"");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _userCode = this._procedureHelpers.userCode(pc, 1);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* include all referenced room classes */");
+    _builder.newLine();
+    {
+      EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(pc);
+      EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(pc);
+      Iterable<RoomClass> _plus = Iterables.<RoomClass>concat(_referencedProtocolClasses, _referencedDataClasses);
+      EList<EnumerationType> _referencedEnumClasses = root.getReferencedEnumClasses(pc);
+      final Function1<RoomClass, String> _function = (RoomClass it) -> {
+        return it.getName();
+      };
+      List<RoomClass> _sortBy = IterableExtensions.<RoomClass, String>sortBy(Iterables.<RoomClass>concat(_plus, _referencedEnumClasses), _function);
+      for(final RoomClass dc : _sortBy) {
+        _builder.append("#include ");
+        String _includePath = this._cExtensions.getIncludePath(dc);
+        _builder.append(_includePath);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.newLine();
+    {
+      CommunicationType _commType = pc.getCommType();
+      boolean _equals = Objects.equal(_commType, CommunicationType.EVENT_DRIVEN);
+      if (_equals) {
+        _builder.newLine();
+        _builder.append("/* message IDs */");
+        _builder.newLine();
+        String _genMessageIDs = this.genMessageIDs(pc);
+        _builder.append(_genMessageIDs);
+        _builder.newLineIfNotEmpty();
+        _builder.newLine();
+        _builder.append("/*--------------------- port structs and methods */");
+        _builder.newLine();
+        CharSequence _portClassHeader = this.portClassHeader(pc, Boolean.valueOf(false));
+        _builder.append(_portClassHeader);
+        _builder.newLineIfNotEmpty();
+        CharSequence _portClassHeader_1 = this.portClassHeader(pc, Boolean.valueOf(true));
+        _builder.append(_portClassHeader_1);
+        _builder.newLineIfNotEmpty();
+      } else {
+        CommunicationType _commType_1 = pc.getCommType();
+        boolean _equals_1 = Objects.equal(_commType_1, CommunicationType.DATA_DRIVEN);
+        if (_equals_1) {
+          _builder.append("/*--------------------- port structs and methods */");
+          _builder.newLine();
+          CharSequence _genDataDrivenPortHeaders = this.genDataDrivenPortHeaders(pc);
+          _builder.append(_genDataDrivenPortHeaders);
+          _builder.newLineIfNotEmpty();
+        } else {
+          CommunicationType _commType_2 = pc.getCommType();
+          boolean _equals_2 = Objects.equal(_commType_2, CommunicationType.SYNCHRONOUS);
+          if (_equals_2) {
+            _builder.append("#error \"synchronoue protocols not implemented yet\"");
+            _builder.newLine();
+          }
+        }
+      }
+    }
+    _builder.newLine();
+    {
+      boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+      if (_isGenerateMSCInstrumentation) {
+        _builder.append("/*--------------------- debug helpers */");
+        _builder.newLine();
+        _builder.newLine();
+        _builder.append("/* get message string for message id */");
+        _builder.newLine();
+        _builder.append("const char* ");
+        String _name_1 = pc.getName();
+        _builder.append(_name_1);
+        _builder.append("_getMessageString(int msg_id);");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.newLine();
+    CharSequence _userCode_1 = this._procedureHelpers.userCode(pc, 2);
+    _builder.append(_userCode_1);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(pc);
+    _builder.append(_generateIncludeGuardEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence generateUtilsFile(final Root root, final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      EObject _eContainer = pc.eContainer();
+      String _replaceAll = ((RoomModel) _eContainer).getName().replaceAll("\\.", "_");
+      String _plus = (_replaceAll + "_");
+      String _name = pc.getName();
+      String _plus_1 = (_plus + _name);
+      final String filename = (_plus_1 + "_Utils");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Utils File of ProtocolClass ");
+      String _name_1 = pc.getName();
+      _builder.append(_name_1, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("* ");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cExtensions.generateIncludeGuardBegin(filename);
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        ProtocolClass _base = pc.getBase();
+        boolean _notEquals = (!Objects.equal(_base, null));
+        if (_notEquals) {
+          _builder.append("// include base class utils");
+          _builder.newLine();
+          _builder.append("#include ");
+          String _utilsIncludePath = this._cExtensions.getUtilsIncludePath(pc.getBase());
+          _builder.append(_utilsIncludePath);
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+        }
+      }
+      _builder.append("#include ");
+      String _includePath = this._cExtensions.getIncludePath(pc);
+      _builder.append(_includePath);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* access macros for operations and attributes");
+      _builder.newLine();
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateUtilsFile = this.generateUtilsFile(pc, false);
+      _builder.append(_generateUtilsFile);
+      _builder.newLineIfNotEmpty();
+      CharSequence _generateUtilsFile_1 = this.generateUtilsFile(pc, true);
+      _builder.append(_generateUtilsFile_1);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cExtensions.generateIncludeGuardEnd(filename);
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateUtilsFile(final ProtocolClass pc, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      final PortClass portClass = this._roomExtensions.getPortClass(pc, conj);
+      final String portClassName = this._roomExtensions.getPortClassName(pc, conj);
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _notEquals = (!Objects.equal(portClass, null));
+        if (_notEquals) {
+          _builder.append("/* ");
+          {
+            if (conj) {
+              _builder.append("conjugate");
+            } else {
+              _builder.append("regular");
+            }
+          }
+          _builder.append(" port class */");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+          _builder.append("/* operations */");
+          _builder.newLine();
+          {
+            EList<PortOperation> _operations = portClass.getOperations();
+            for(final PortOperation op : _operations) {
+              final CharSequence args = this.argList(op);
+              _builder.newLineIfNotEmpty();
+              _builder.append("#define ");
+              String _name = op.getName();
+              _builder.append(_name);
+              _builder.append("(");
+              _builder.append(args);
+              _builder.append(") ");
+              _builder.append(portClassName);
+              _builder.append("_");
+              String _name_1 = op.getName();
+              _builder.append(_name_1);
+              _builder.append("(self");
+              {
+                boolean _isEmpty = op.getArguments().isEmpty();
+                boolean _not = (!_isEmpty);
+                if (_not) {
+                  _builder.append(", ");
+                  _builder.append(args);
+                }
+              }
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          _builder.append("/* attributes */");
+          _builder.newLine();
+          {
+            EList<Attribute> _attributes = portClass.getAttributes();
+            for(final Attribute a : _attributes) {
+              _builder.append("#define ");
+              String _name_2 = a.getName();
+              _builder.append(_name_2);
+              _builder.append(" (((");
+              _builder.append(portClassName);
+              _builder.append("_var*)(self->varData))->");
+              String _name_3 = a.getName();
+              _builder.append(_name_3);
+              _builder.append(")");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence argList(final Operation op) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<VarDecl> _arguments = op.getArguments();
+      boolean _hasElements = false;
+      for(final VarDecl a : _arguments) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(", ", "");
+        }
+        String _name = a.getName();
+        _builder.append(_name);
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence generateSourceFile(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Source File of ProtocolClass ");
+    String _name = pc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("* ");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("#include \"");
+    String _cHeaderFileName = this._cExtensions.getCHeaderFileName(pc);
+    _builder.append(_cHeaderFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.append("#include \"debugging/etMSCLogger.h\"");
+    _builder.newLine();
+    _builder.append("#include \"");
+    String _cUtilsFileName = this._cExtensions.getCUtilsFileName(pc);
+    _builder.append(_cUtilsFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _userCode = this._procedureHelpers.userCode(pc, 3);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/*--------------------- port methods */");
+    _builder.newLine();
+    {
+      CommunicationType _commType = pc.getCommType();
+      boolean _equals = Objects.equal(_commType, CommunicationType.EVENT_DRIVEN);
+      if (_equals) {
+        CharSequence _portClassSource = this.portClassSource(pc, Boolean.valueOf(false));
+        _builder.append(_portClassSource);
+        _builder.newLineIfNotEmpty();
+        CharSequence _portClassSource_1 = this.portClassSource(pc, Boolean.valueOf(true));
+        _builder.append(_portClassSource_1);
+        _builder.newLineIfNotEmpty();
+        _builder.newLine();
+        {
+          boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+          if (_isGenerateMSCInstrumentation) {
+            _builder.append("/*--------------------- debug helpers */");
+            _builder.newLine();
+            CharSequence _generateDebugHelpersImplementation = this.generateDebugHelpersImplementation(root, pc);
+            _builder.append(_generateDebugHelpersImplementation);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      } else {
+        CommunicationType _commType_1 = pc.getCommType();
+        boolean _equals_1 = Objects.equal(_commType_1, CommunicationType.DATA_DRIVEN);
+        if (_equals_1) {
+          CharSequence _genDataDrivenPortSources = this.genDataDrivenPortSources(pc);
+          _builder.append(_genDataDrivenPortSources);
+          _builder.newLineIfNotEmpty();
+        } else {
+          CommunicationType _commType_2 = pc.getCommType();
+          boolean _equals_2 = Objects.equal(_commType_2, CommunicationType.SYNCHRONOUS);
+          if (_equals_2) {
+            _builder.append("#error \"synchronous protocols not implemented yet\"");
+            _builder.newLine();
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence portClassHeader(final ProtocolClass pc, final Boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      String portClassName = this._roomExtensions.getPortClassName(pc, (conj).booleanValue());
+      String replPortClassName = this._roomExtensions.getPortClassName(pc, (conj).booleanValue(), true);
+      List<Message> _xifexpression = null;
+      if ((conj).booleanValue()) {
+        _xifexpression = this._roomHelpers.getAllIncomingMessages(pc);
+      } else {
+        _xifexpression = this._roomHelpers.getAllOutgoingMessages(pc);
+      }
+      List<Message> messages = _xifexpression;
+      final List<PortClass> allPortClasses = this._roomExtensions.getAllPortClasses(pc, (conj).booleanValue());
+      final Function1<PortClass, EList<Attribute>> _function = (PortClass p) -> {
+        return p.getAttributes();
+      };
+      final List<Attribute> allAttributes = IterableExtensions.<Attribute>toList(Iterables.<Attribute>concat(ListExtensions.<PortClass, EList<Attribute>>map(allPortClasses, _function)));
+      final Function1<PortClass, EList<PortOperation>> _function_1 = (PortClass p) -> {
+        return p.getOperations();
+      };
+      final List<PortOperation> allOperations = IterableExtensions.<PortOperation>toList(Iterables.<PortOperation>concat(ListExtensions.<PortClass, EList<PortOperation>>map(allPortClasses, _function_1)));
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("typedef etPort ");
+      _builder.append(portClassName);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.append("typedef etReplPort ");
+      _builder.append(replPortClassName);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        boolean _isEmpty = allAttributes.isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("/* variable part of PortClass (RAM) */");
+          _builder.newLine();
+          _builder.append("typedef struct ");
+          _builder.append(portClassName);
+          _builder.append("_var ");
+          _builder.append(portClassName);
+          _builder.append("_var; ");
+          _builder.newLineIfNotEmpty();
+          _builder.append("struct ");
+          _builder.append(portClassName);
+          _builder.append("_var {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _attributes = this._procedureHelpers.attributes(allAttributes);
+          _builder.append(_attributes, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("};");
+          _builder.newLine();
+          {
+            for(final Attribute a : allAttributes) {
+              {
+                String _defaultValueLiteral = a.getDefaultValueLiteral();
+                boolean _notEquals = (!Objects.equal(_defaultValueLiteral, null));
+                if (_notEquals) {
+                  String _name = a.getName();
+                  String _plus = ((portClassName + " ") + _name);
+                  String _plus_1 = (_plus + ": Attribute initialization not supported in C");
+                  this.logger.logInfo(_plus_1);
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        for(final Message message : messages) {
+          VarDecl _data = message.getData();
+          boolean hasData = (!Objects.equal(_data, null));
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_1 = null;
+          if (hasData) {
+            _xifexpression_1 = this._typeHelpers.typeName(message.getData().getRefType().getType());
+          } else {
+            _xifexpression_1 = "";
+          }
+          String typeName = _xifexpression_1;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_2 = null;
+          if ((hasData && ((!this._typeHelpers.isEnumerationOrPrimitive(message.getData().getRefType().getType())) || message.getData().getRefType().isRef()))) {
+            _xifexpression_2 = "*";
+          } else {
+            _xifexpression_2 = "";
+          }
+          String refp = _xifexpression_2;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_3 = null;
+          if (hasData) {
+            _xifexpression_3 = (((", " + typeName) + refp) + " data");
+          } else {
+            _xifexpression_3 = "";
+          }
+          String data = _xifexpression_3;
+          _builder.newLineIfNotEmpty();
+          String _messageSignature = this.messageSignature(portClassName, message.getName(), "", data);
+          _builder.append(_messageSignature);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          String _messageSignature_1 = this.messageSignature(replPortClassName, message.getName(), "_broadcast", data);
+          _builder.append(_messageSignature_1);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          String _messageSignature_2 = this.messageSignature(replPortClassName, message.getName(), "", (", int idx" + data));
+          _builder.append(_messageSignature_2);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_1 = allOperations.isEmpty();
+        boolean _not_1 = (!_isEmpty_1);
+        if (_not_1) {
+          CharSequence _operationsDeclaration = this._procedureHelpers.operationsDeclaration(allOperations, portClassName);
+          _builder.append(_operationsDeclaration);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _handlesReceiveIncludingSuper = this._roomExtensions.handlesReceiveIncludingSuper(pc, (conj).booleanValue());
+        if (_handlesReceiveIncludingSuper) {
+          {
+            List<MessageHandler> _receiveHandlersIncludingSuper = this._roomExtensions.getReceiveHandlersIncludingSuper(pc, (conj).booleanValue());
+            for(final MessageHandler h : _receiveHandlersIncludingSuper) {
+              _builder.append("void ");
+              _builder.append(portClassName);
+              _builder.append("_");
+              String _name_1 = h.getMsg().getName();
+              _builder.append(_name_1);
+              _builder.append("_receiveHandler(");
+              _builder.append(portClassName);
+              _builder.append("* self, const etMessage* msg, void * actor, etActorReceiveMessage receiveMessageFunc);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("etInt32 ");
+      _builder.append(replPortClassName);
+      _builder.append("_getReplication(const ");
+      _builder.append(replPortClassName);
+      _builder.append("* self);");
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genDataDrivenPortHeaders(final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      Iterable<Message> sentMsgs = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      final Function1<Message, Boolean> _function_1 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isEnumeration(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> enumMsgs = IterableExtensions.<Message>filter(sentMsgs, _function_1);
+      final Function1<Message, Boolean> _function_2 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isBoolean(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> boolMsgs = IterableExtensions.<Message>filter(sentMsgs, _function_2);
+      final boolean usesMSC = (Main.getSettings().isGenerateMSCInstrumentation() && (!(IterableExtensions.isEmpty(enumMsgs) && IterableExtensions.isEmpty(boolMsgs))));
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/* data driven send port (conjugated) */");
+      _builder.newLine();
+      _builder.append("typedef struct ");
+      String _portClassName = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      {
+        for(final Message msg : sentMsgs) {
+          _builder.append("\t");
+          String typeName = this._typeHelpers.typeName(msg.getData().getRefType().getType());
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          String _xifexpression = null;
+          boolean _isRef = msg.getData().getRefType().isRef();
+          if (_isRef) {
+            _xifexpression = "*";
+          } else {
+            _xifexpression = "";
+          }
+          String refp = _xifexpression;
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(typeName, "\t");
+          _builder.append(refp, "\t");
+          _builder.append(" ");
+          String _name = msg.getName();
+          _builder.append(_name, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        if (usesMSC) {
+          _builder.append("\t");
+          _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("const char* instName;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("const char** peerNames;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("#endif");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      String _portClassName_1 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_1);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("/* data driven receive port (regular) */");
+      _builder.newLine();
+      _builder.append("typedef struct ");
+      String _portClassName_2 = this._roomExtensions.getPortClassName(pc, false);
+      _builder.append(_portClassName_2);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("const ");
+      String _portClassName_3 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_3, "\t");
+      _builder.append("* peer;");
+      _builder.newLineIfNotEmpty();
+      {
+        if (usesMSC) {
+          _builder.append("\t");
+          _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("const char* instName;");
+          _builder.newLine();
+          {
+            for(final Message msg_1 : enumMsgs) {
+              _builder.append("\t");
+              _builder.append("\t");
+              String typeName_1 = this._typeHelpers.typeName(msg_1.getData().getRefType().getType());
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              String _xifexpression_1 = null;
+              boolean _isRef_1 = msg_1.getData().getRefType().isRef();
+              if (_isRef_1) {
+                _xifexpression_1 = "*";
+              } else {
+                _xifexpression_1 = "";
+              }
+              String refp_1 = _xifexpression_1;
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append(typeName_1, "\t\t");
+              _builder.append(refp_1, "\t\t");
+              _builder.append(" ");
+              String _name_1 = msg_1.getName();
+              _builder.append(_name_1, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          {
+            for(final Message msg_2 : boolMsgs) {
+              _builder.append("\t");
+              _builder.append("\t");
+              String typeName_2 = this._typeHelpers.typeName(msg_2.getData().getRefType().getType());
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              String _xifexpression_2 = null;
+              boolean _isRef_2 = msg_2.getData().getRefType().isRef();
+              if (_isRef_2) {
+                _xifexpression_2 = "*";
+              } else {
+                _xifexpression_2 = "";
+              }
+              String refp_2 = _xifexpression_2;
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append(typeName_2, "\t\t");
+              _builder.append(refp_2, "\t\t");
+              _builder.append(" ");
+              String _name_2 = msg_2.getName();
+              _builder.append(_name_2, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("#endif");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      String _portClassName_4 = this._roomExtensions.getPortClassName(pc, false);
+      _builder.append(_portClassName_4);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        for(final Message message : sentMsgs) {
+          VarDecl _data = message.getData();
+          boolean hasData = (!Objects.equal(_data, null));
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_3 = null;
+          if (hasData) {
+            _xifexpression_3 = this._typeHelpers.typeName(message.getData().getRefType().getType());
+          } else {
+            _xifexpression_3 = "";
+          }
+          String typeName_3 = _xifexpression_3;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_4 = null;
+          if ((hasData && (!this._typeHelpers.isEnumerationOrPrimitive(message.getData().getRefType().getType())))) {
+            _xifexpression_4 = "*";
+          } else {
+            _xifexpression_4 = "";
+          }
+          String refp_3 = _xifexpression_4;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_5 = null;
+          if (hasData) {
+            _xifexpression_5 = (((", " + typeName_3) + refp_3) + " data");
+          } else {
+            _xifexpression_5 = "";
+          }
+          String data = _xifexpression_5;
+          _builder.newLineIfNotEmpty();
+          String _messageSetterSignature = this.messageSetterSignature(this._roomExtensions.getPortClassName(pc, true), message.getName(), data);
+          _builder.append(_messageSetterSignature);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          String _messageGetterSignature = this.messageGetterSignature(this._roomExtensions.getPortClassName(pc, false), message.getName(), typeName_3);
+          _builder.append(_messageGetterSignature);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genDataDrivenPortSources(final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      Iterable<Message> messages = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      final Function1<Message, Boolean> _function_1 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isEnumeration(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> enumMsgs = IterableExtensions.<Message>filter(messages, _function_1);
+      final Function1<Message, Boolean> _function_2 = (Message m) -> {
+        return Boolean.valueOf(this._typeHelpers.isBoolean(m.getData().getRefType().getType()));
+      };
+      final Iterable<Message> boolMsgs = IterableExtensions.<Message>filter(messages, _function_2);
+      final boolean usesMSC = (Main.getSettings().isGenerateMSCInstrumentation() && (!(IterableExtensions.isEmpty(enumMsgs) && IterableExtensions.isEmpty(boolMsgs))));
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        for(final Message message : messages) {
+          String typeName = this._typeHelpers.typeName(message.getData().getRefType().getType());
+          _builder.newLineIfNotEmpty();
+          String _xifexpression = null;
+          boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(message.getData().getRefType().getType());
+          boolean _not = (!_isEnumerationOrPrimitive);
+          if (_not) {
+            _xifexpression = "*";
+          } else {
+            _xifexpression = "";
+          }
+          String refp = _xifexpression;
+          _builder.newLineIfNotEmpty();
+          String data = (((", " + typeName) + refp) + " data");
+          _builder.newLineIfNotEmpty();
+          String _messageSetterSignature = this.messageSetterSignature(this._roomExtensions.getPortClassName(pc, true), message.getName(), data);
+          _builder.append(_messageSetterSignature);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          {
+            if ((usesMSC && IterableExtensions.<Message>exists(enumMsgs, ((Function1<Message, Boolean>) (Message m) -> {
+              return Boolean.valueOf(Objects.equal(m, message));
+            })))) {
+              _builder.append("\t");
+              _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("{");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("const char** peerName;");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("for (peerName=self->peerNames; *peerName!=NULL; ++peerName) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t\t");
+              _builder.append("ET_MSC_LOGGER_ASYNC_OUT(self->instName, ");
+              String _name = message.getData().getRefType().getType().getName();
+              _builder.append(_name, "\t\t\t\t");
+              _builder.append("_getLiteralName(data), *peerName)");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t\t\t");
+              _builder.append("ET_MSC_LOGGER_ASYNC_IN(self->instName, ");
+              String _name_1 = message.getData().getRefType().getType().getName();
+              _builder.append(_name_1, "\t\t\t\t");
+              _builder.append("_getLiteralName(data), *peerName)");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("#endif");
+              _builder.newLine();
+            }
+          }
+          {
+            if ((usesMSC && IterableExtensions.<Message>exists(boolMsgs, ((Function1<Message, Boolean>) (Message m) -> {
+              return Boolean.valueOf(Objects.equal(m, message));
+            })))) {
+              _builder.append("\t");
+              _builder.append("#ifdef ET_ASYNC_MSC_LOGGER_ACTIVATE");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("{");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("const char** peerName;");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("for (peerName=self->peerNames; *peerName!=NULL; ++peerName) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t\t");
+              _builder.append("ET_MSC_LOGGER_ASYNC_OUT(self->instName, data?\"true\":\"false\", *peerName)");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t\t");
+              _builder.append("ET_MSC_LOGGER_ASYNC_IN(self->instName, data?\"true\":\"false\", *peerName)");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("#endif");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("self->");
+          String _name_2 = message.getName();
+          _builder.append(_name_2, "\t");
+          _builder.append(" = ");
+          _builder.append(refp, "\t");
+          _builder.append("data;");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          String _messageGetterSignature = this.messageGetterSignature(this._roomExtensions.getPortClassName(pc, false), message.getName(), typeName);
+          _builder.append(_messageGetterSignature);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("return self->peer->");
+          String _name_3 = message.getName();
+          _builder.append(_name_3, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence portClassSource(final ProtocolClass pc, final Boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      final List<PortClass> allPortClasses = this._roomExtensions.getAllPortClasses(pc, (conj).booleanValue());
+      final String portClassName = this._roomExtensions.getPortClassName(pc, (conj).booleanValue());
+      final String replPortClassName = this._roomExtensions.getPortClassName(pc, (conj).booleanValue(), true);
+      List<Message> _xifexpression = null;
+      if ((conj).booleanValue()) {
+        _xifexpression = this._roomHelpers.getAllIncomingMessages(pc);
+      } else {
+        _xifexpression = this._roomHelpers.getAllOutgoingMessages(pc);
+      }
+      final List<Message> messages = _xifexpression;
+      String _xifexpression_1 = null;
+      if ((conj).booleanValue()) {
+        _xifexpression_1 = "IN_";
+      } else {
+        _xifexpression_1 = "OUT_";
+      }
+      final String dir = _xifexpression_1;
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        for(final Message message : messages) {
+          VarDecl _data = message.getData();
+          boolean hasData = (!Objects.equal(_data, null));
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_2 = null;
+          if (hasData) {
+            _xifexpression_2 = this._typeHelpers.typeName(message.getData().getRefType().getType());
+          } else {
+            _xifexpression_2 = "";
+          }
+          String typeName = _xifexpression_2;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_3 = null;
+          if ((hasData && message.getData().getRefType().isRef())) {
+            _xifexpression_3 = "*";
+          } else {
+            _xifexpression_3 = "";
+          }
+          String refp = _xifexpression_3;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_4 = null;
+          if ((hasData && ((!this._typeHelpers.isEnumerationOrPrimitive(message.getData().getRefType().getType())) || message.getData().getRefType().isRef()))) {
+            _xifexpression_4 = "*";
+          } else {
+            _xifexpression_4 = "";
+          }
+          String refpd = _xifexpression_4;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_5 = null;
+          if (((hasData && (!this._typeHelpers.isEnumerationOrPrimitive(message.getData().getRefType().getType()))) && (!message.getData().getRefType().isRef()))) {
+            _xifexpression_5 = "";
+          } else {
+            _xifexpression_5 = "&";
+          }
+          String refa = _xifexpression_5;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_6 = null;
+          if (hasData) {
+            _xifexpression_6 = (((", " + typeName) + refpd) + " data__et");
+          } else {
+            _xifexpression_6 = "";
+          }
+          String data = _xifexpression_6;
+          _builder.newLineIfNotEmpty();
+          String _xifexpression_7 = null;
+          if (hasData) {
+            _xifexpression_7 = ", data__et";
+          } else {
+            _xifexpression_7 = "";
+          }
+          String dataCall = _xifexpression_7;
+          _builder.newLineIfNotEmpty();
+          MessageHandler hdlr = this._roomExtensions.getSendHandler(message, (conj).booleanValue());
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+          String _messageSignature = this.messageSignature(portClassName, message.getName(), "", data);
+          _builder.append(_messageSignature);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _notEquals = (!Objects.equal(hdlr, null));
+            if (_notEquals) {
+              _builder.append("\t");
+              String _translatedCode = AbstractGenerator.getInstance().getTranslatedCode(hdlr.getDetailCode());
+              _builder.append(_translatedCode, "\t");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+              _builder.append(portClassName, "\t");
+              _builder.append("\", \"");
+              String _name = message.getName();
+              _builder.append(_name, "\t");
+              _builder.append("\")");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              String _name_1 = pc.getName();
+              String _name_2 = message.getName();
+              String _plus = (dir + _name_2);
+              String _sendMessageCall = this.sendMessageCall(hasData, "self", this._cExtensions.memberInUse(_name_1, _plus), (typeName + refp), (refa + "data__et"));
+              _builder.append(_sendMessageCall, "\t\t");
+              _builder.newLineIfNotEmpty();
+              {
+                boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+                if (_isGenerateMSCInstrumentation) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("ET_MSC_LOGGER_ASYNC_OUT(self->myInstName, \"");
+                  String _name_3 = message.getName();
+                  _builder.append(_name_3, "\t\t");
+                  _builder.append("\", self->peerInstName)");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+              _builder.newLine();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          String _messageSignature_1 = this.messageSignature(replPortClassName, message.getName(), "_broadcast", data);
+          _builder.append(_messageSignature_1);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _notEquals_1 = (!Objects.equal(hdlr, null));
+            if (_notEquals_1) {
+              _builder.append("\t");
+              _builder.append("int i;");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("for (i=0; i<((etReplPort*)self)->size; ++i) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append(portClassName, "\t\t");
+              _builder.append("_");
+              String _name_4 = message.getName();
+              _builder.append(_name_4, "\t\t");
+              _builder.append("(&((etReplPort*)self)->ports[i].port");
+              _builder.append(dataCall, "\t\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("}\t\t\t\t\t");
+              _builder.newLine();
+            } else {
+              _builder.append("\t");
+              _builder.append("int i;");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+              _builder.append(replPortClassName, "\t");
+              _builder.append("\", \"");
+              String _name_5 = message.getName();
+              _builder.append(_name_5, "\t");
+              _builder.append("\")");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("for (i=0; i<((etReplPort*)self)->size; ++i) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              String _name_6 = pc.getName();
+              String _name_7 = message.getName();
+              String _plus_1 = (dir + _name_7);
+              String _sendMessageCall_1 = this.sendMessageCall(hasData, "(&((etReplPort*)self)->ports[i].port)", this._cExtensions.memberInUse(_name_6, _plus_1), (typeName + refp), (refa + "data__et"));
+              _builder.append(_sendMessageCall_1, "\t\t");
+              _builder.newLineIfNotEmpty();
+              {
+                boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+                if (_isGenerateMSCInstrumentation_1) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("ET_MSC_LOGGER_ASYNC_OUT(((etReplPort*)self)->ports[i].port.myInstName, \"");
+                  String _name_8 = message.getName();
+                  _builder.append(_name_8, "\t\t");
+                  _builder.append("\", ((etReplPort*)self)->ports[i].port.peerInstName)");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+              _builder.newLine();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          String _messageSignature_2 = this.messageSignature(replPortClassName, message.getName(), "", (", int idx__et" + data));
+          _builder.append(_messageSignature_2);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _notEquals_2 = (!Objects.equal(hdlr, null));
+            if (_notEquals_2) {
+              _builder.append("\t");
+              _builder.append(portClassName, "\t");
+              _builder.append("_");
+              String _name_9 = message.getName();
+              _builder.append(_name_9, "\t");
+              _builder.append("(&((etReplPort*)self)->ports[idx__et].port");
+              _builder.append(dataCall, "\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_ENTRY(\"");
+              _builder.append(replPortClassName, "\t");
+              _builder.append("\", \"");
+              String _name_10 = message.getName();
+              _builder.append(_name_10, "\t");
+              _builder.append("\")");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("if (0<=idx__et && idx__et<((etReplPort*)self)->size) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              String _name_11 = pc.getName();
+              String _name_12 = message.getName();
+              String _plus_2 = (dir + _name_12);
+              String _sendMessageCall_2 = this.sendMessageCall(hasData, "(&((etReplPort*)self)->ports[idx__et].port)", this._cExtensions.memberInUse(_name_11, _plus_2), (typeName + refp), (refa + "data__et"));
+              _builder.append(_sendMessageCall_2, "\t\t");
+              _builder.newLineIfNotEmpty();
+              {
+                boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+                if (_isGenerateMSCInstrumentation_2) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("ET_MSC_LOGGER_ASYNC_OUT(((etReplPort*)self)->ports[idx__et].port.myInstName, \"");
+                  String _name_13 = message.getName();
+                  _builder.append(_name_13, "\t\t");
+                  _builder.append("\", ((etReplPort*)self)->ports[idx__et].port.peerInstName)");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("ET_MSC_LOGGER_SYNC_EXIT");
+              _builder.newLine();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isEmpty = allPortClasses.isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("/* begin ");
+          _builder.append(portClassName);
+          _builder.append(" specific (including base classes) */");
+          _builder.newLineIfNotEmpty();
+          {
+            for(final PortClass p : allPortClasses) {
+              CharSequence _userCode = this._procedureHelpers.userCode(p.getUserCode());
+              _builder.append(_userCode);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          {
+            for(final PortClass p_1 : allPortClasses) {
+              CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(p_1.getOperations(), portClassName);
+              _builder.append(_operationsImplementation);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("/* end ");
+          _builder.append(portClassName);
+          _builder.append(" specific (including base classes) */");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+        }
+      }
+      _builder.append("etInt32 ");
+      _builder.append(replPortClassName);
+      _builder.append("_getReplication(const ");
+      _builder.append(replPortClassName);
+      _builder.append("* self) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("return ((etReplPort*)self)->size;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _handlesReceive = this._roomExtensions.handlesReceive(pc, (conj).booleanValue());
+        if (_handlesReceive) {
+          CharSequence _genReceiveHandlers = this.genReceiveHandlers(pc, conj);
+          _builder.append(_genReceiveHandlers);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String sendMessageCall(final boolean hasData, final String selfPtr, final String msg, final String typeName, final String data) {
+    String _xifexpression = null;
+    if (hasData) {
+      _xifexpression = (((((((("etPort_sendMessage(" + selfPtr) + ", ") + msg) + ", sizeof(") + typeName) + "), ") + data) + ");");
+    } else {
+      _xifexpression = (((("etPort_sendMessage(" + selfPtr) + ", ") + msg) + ", 0, NULL);");
+    }
+    return _xifexpression;
+  }
+  
+  private String messageSignature(final String className, final String messageName, final String methodSuffix, final String data) {
+    return ((((((((("void " + className) + "_") + messageName) + methodSuffix) + "(const ") + className) + "* self") + data) + ")");
+  }
+  
+  private String messageSetterSignature(final String className, final String messageName, final String data) {
+    return (((((((("void " + className) + "_") + messageName) + "_set(") + className) + "* self") + data) + ")");
+  }
+  
+  private String messageGetterSignature(final String className, final String messageName, final String type) {
+    return (((((((type + " ") + className) + "_") + messageName) + "_get(const ") + className) + "* const self)");
+  }
+  
+  private CharSequence genReceiveHandlers(final ProtocolClass pc, final Boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      String portClassName = this._roomExtensions.getPortClassName(pc, (conj).booleanValue());
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/* receiver handlers */");
+      _builder.newLine();
+      {
+        List<MessageHandler> _receiveHandlers = this._roomExtensions.getReceiveHandlers(pc, (conj).booleanValue());
+        for(final MessageHandler h : _receiveHandlers) {
+          _builder.append("void ");
+          _builder.append(portClassName);
+          _builder.append("_");
+          String _name = h.getMsg().getName();
+          _builder.append(_name);
+          _builder.append("_receiveHandler(");
+          _builder.append(portClassName);
+          _builder.append("* self, const etMessage* msg, void * actor, etActorReceiveMessage receiveMessageFunc){");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          String _translatedCode = AbstractGenerator.getInstance().getTranslatedCode(h.getDetailCode());
+          _builder.append(_translatedCode, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("/* hand over the message to the actor:      */");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/* (*receiveMessageFunc)(actor, self, msg); */");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateDebugHelpersImplementation(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.newLine();
+    _builder.append("/* message names as strings for debugging (generate MSC) */");
+    _builder.newLine();
+    _builder.append("static const char* const ");
+    String _name = pc.getName();
+    _builder.append(_name);
+    _builder.append("_messageStrings[] = {\"MIN\", ");
+    {
+      List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+      for(final Message m : _allOutgoingMessages) {
+        _builder.append("\"");
+        String _name_1 = m.getName();
+        _builder.append(_name_1);
+        _builder.append("\",");
+      }
+    }
+    {
+      List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+      for(final Message m_1 : _allIncomingMessages) {
+        _builder.append("\"");
+        String _name_2 = m_1.getName();
+        _builder.append(_name_2);
+        _builder.append("\", ");
+      }
+    }
+    _builder.append("\"MAX\"};");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("const char* ");
+    String _name_3 = pc.getName();
+    _builder.append(_name_3);
+    _builder.append("_getMessageString(int msg_id) {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("if (msg_id<");
+    String _name_4 = pc.getName();
+    _builder.append(_name_4, "\t");
+    _builder.append("_MSG_MIN || msg_id>");
+    String _name_5 = pc.getName();
+    _builder.append(_name_5, "\t");
+    _builder.append("_MSG_MAX+1){");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("/* id out of range */");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("return \"Message ID out of range\";");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("else{");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("return ");
+    String _name_6 = pc.getName();
+    _builder.append(_name_6, "\t\t");
+    _builder.append("_messageStrings[msg_id];");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/StateMachineGen.java b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/StateMachineGen.java
new file mode 100644
index 000000000..ab2ca76cf
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.c/xtend-gen/org/eclipse/etrice/generator/c/gen/StateMachineGen.java
@@ -0,0 +1,225 @@
+/**
+ * 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.generator.c.gen;
+
+import com.google.common.collect.Iterators;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
+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.Node;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.generator.c.Main;
+import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class StateMachineGen extends GenericStateMachineGenerator {
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  public CharSequence genHeaderConstants(final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      final Function1<Node, Boolean> _function = (Node it) -> {
+        boolean _isInherited = it.isInherited();
+        return Boolean.valueOf((!_isInherited));
+      };
+      int _size = IteratorExtensions.size(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(xpac.getGraphContainer().getGraph()), _function));
+      final Function1<Node, Boolean> _function_1 = (Node it) -> {
+        return Boolean.valueOf(FsmGenExtensions.isLeaf(it));
+      };
+      int _size_1 = IteratorExtensions.size(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(xpac.getGraphContainer().getGraph()), _function_1));
+      int _minus = (_size - _size_1);
+      final int historySize = (_minus + 2);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/* constant for state machine data */");
+      _builder.newLine();
+      _builder.append("#define ");
+      String _upperCase = ac.getName().toUpperCase();
+      _builder.append(_upperCase);
+      _builder.append("_HISTORY_SIZE ");
+      _builder.append(historySize);
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence genDataMembers(final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/* state machine variables */");
+      _builder.newLine();
+      _builder.append("etInt16 state;");
+      _builder.newLine();
+      _builder.append("etInt16 history[");
+      String _upperCase = ac.getName().toUpperCase();
+      _builder.append(_upperCase);
+      _builder.append("_HISTORY_SIZE];");
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence genInitialization(final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("self->state = STATE_TOP;");
+      _builder.newLine();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("int i;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("for (i=0; i<");
+      String _upperCase = ac.getName().toUpperCase();
+      _builder.append(_upperCase, "\t");
+      _builder.append("_HISTORY_SIZE; ++i)");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("self->history[i] = NO_STATE;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      String _operationScope = this.langExt.operationScope(ac.getName(), false);
+      _builder.append(_operationScope);
+      _builder.append("executeInitTransition(self);");
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * @param generateImplementation NOT used
+   */
+  @Override
+  public CharSequence genExtra(final GraphContainer gc, final boolean generateImplementation) {
+    CharSequence _xblockexpression = null;
+    {
+      final ModelComponent mc = gc.getComponent();
+      final Function1<Node, StateGraphNode> _function = (Node it) -> {
+        return it.getStateGraphNode();
+      };
+      final List<State> allStates = IteratorExtensions.<State>toList(Iterators.<State>filter(IteratorExtensions.<Node, StateGraphNode>map(FsmGenExtensions.getAllStateNodes(gc.getGraph()), _function), State.class));
+      final Iterable<State> states = this._roomExtensions.getLeafStatesLast(allStates);
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("/* state names */");
+          _builder.newLine();
+          _builder.append("static char* stateStrings[] = {\"<no state>\",\"<top>\",");
+          {
+            boolean _hasElements = false;
+            for(final State state : states) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate(",", "");
+              }
+              _builder.append("\"");
+              String _genStatePathName = this._codegenHelpers.getGenStatePathName(state);
+              _builder.append(_genStatePathName);
+              _builder.append("\"");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("};");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      String _accessLevelPrivate = this.langExt.accessLevelPrivate();
+      _builder.append(_accessLevelPrivate);
+      _builder.append("void setState(");
+      String _componentName = mc.getComponentName();
+      _builder.append(_componentName);
+      _builder.append("* self, ");
+      String _stateType = this.stateType();
+      _builder.append(_stateType);
+      _builder.append(" new_state) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("self->state = new_state;");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.append("\t");
+          _builder.append("ET_MSC_LOGGER_CHANGE_STATE(self->constData->instName, stateStrings[new_state])");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      String _accessLevelPrivate_1 = this.langExt.accessLevelPrivate();
+      _builder.append(_accessLevelPrivate_1);
+      String _stateType_1 = this.stateType();
+      _builder.append(_stateType_1);
+      _builder.append(" getState(");
+      String _componentName_1 = mc.getComponentName();
+      _builder.append(_componentName_1);
+      _builder.append("* self) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("return self->state;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String stateType() {
+    return "etInt16";
+  }
+  
+  @Override
+  public String boolType() {
+    return "etBool";
+  }
+  
+  @Override
+  public CharSequence markVariableUsed(final String varname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("((void)trigger__et);\t/* avoids unused warning */");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  @Override
+  public String unreachableReturn() {
+    return "/* return NO_STATE; // required by CDT but detected as unreachable by JDT because of while (true) */";
+  }
+}
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.config/xtend-gen/org/eclipse/etrice/generator/config/DataConfiguration.java b/plugins/org.eclipse.etrice.generator.config/xtend-gen/org/eclipse/etrice/generator/config/DataConfiguration.java
new file mode 100644
index 000000000..b0567c415
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.config/xtend-gen/org/eclipse/etrice/generator/config/DataConfiguration.java
@@ -0,0 +1,444 @@
+/**
+ * Copyright (c) 2012 Juergen Haug
+ * 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
+ */
+package org.eclipse.etrice.generator.config;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.EMFPlugin;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.etrice.core.ConfigStandaloneSetup;
+import org.eclipse.etrice.core.common.base.BooleanLiteral;
+import org.eclipse.etrice.core.common.base.IntLiteral;
+import org.eclipse.etrice.core.common.base.Literal;
+import org.eclipse.etrice.core.common.base.NumberLiteral;
+import org.eclipse.etrice.core.common.base.RealLiteral;
+import org.eclipse.etrice.core.common.base.StringLiteral;
+import org.eclipse.etrice.core.config.AttrClassConfig;
+import org.eclipse.etrice.core.config.AttrInstanceConfig;
+import org.eclipse.etrice.core.config.ConfigValue;
+import org.eclipse.etrice.core.config.ConfigValueArray;
+import org.eclipse.etrice.core.config.DynamicConfig;
+import org.eclipse.etrice.core.config.EnumConfigValue;
+import org.eclipse.etrice.core.config.LiteralConfigValue;
+import org.eclipse.etrice.core.config.SubSystemConfig;
+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;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+import org.eclipse.etrice.generator.config.util.DataConfigurationHelper;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.scoping.impl.ImportUriResolver;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class DataConfiguration implements IDataConfiguration {
+  @Inject
+  @Extension
+  protected DataConfigurationHelper _dataConfigurationHelper;
+  
+  @Inject
+  protected ILogger logger;
+  
+  @Inject
+  protected ImportUriResolver uriResolver;
+  
+  @Override
+  public void doSetup() {
+    if ((!EMFPlugin.IS_ECLIPSE_RUNNING)) {
+      ConfigStandaloneSetup.doSetup();
+    }
+  }
+  
+  @Override
+  public boolean setResources(final ResourceSet resource, final ILogger logger) {
+    return this._dataConfigurationHelper.setConfigModels(resource, logger);
+  }
+  
+  @Override
+  public String getAttrClassConfigValue(final ActorClass actor, final List<Attribute> path) {
+    AttrClassConfig _attrClassConfig = this.getAttrClassConfig(actor, path);
+    ConfigValueArray _value = null;
+    if (_attrClassConfig!=null) {
+      _value=_attrClassConfig.getValue();
+    }
+    String _stringExpr = null;
+    if (_value!=null) {
+      _stringExpr=this.toStringExpr(_value);
+    }
+    return _stringExpr;
+  }
+  
+  @Override
+  public String getAttrClassConfigMaxValue(final ActorClass actor, final List<Attribute> path) {
+    AttrClassConfig _attrClassConfig = this.getAttrClassConfig(actor, path);
+    NumberLiteral _max = null;
+    if (_attrClassConfig!=null) {
+      _max=_attrClassConfig.getMax();
+    }
+    String _stringExpr = null;
+    if (_max!=null) {
+      _stringExpr=this.toStringExpr(_max);
+    }
+    return _stringExpr;
+  }
+  
+  @Override
+  public String getAttrClassConfigMinValue(final ActorClass actor, final List<Attribute> path) {
+    AttrClassConfig _attrClassConfig = this.getAttrClassConfig(actor, path);
+    NumberLiteral _min = null;
+    if (_attrClassConfig!=null) {
+      _min=_attrClassConfig.getMin();
+    }
+    String _stringExpr = null;
+    if (_min!=null) {
+      _stringExpr=this.toStringExpr(_min);
+    }
+    return _stringExpr;
+  }
+  
+  private AttrClassConfig getAttrClassConfig(final ActorClass actor, final List<Attribute> path) {
+    AttrClassConfig _xblockexpression = null;
+    {
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/");
+      String _name = actor.getName();
+      _builder.append(_name);
+      _builder.append("/");
+      String _stringPath = this.toStringPath(path);
+      _builder.append(_stringPath);
+      String id = _builder.toString();
+      _xblockexpression = this._dataConfigurationHelper.actorClassAttrMap.get(id);
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getAttrClassConfigValue(final ProtocolClass pc, final boolean regular, final List<Attribute> path) {
+    String _xblockexpression = null;
+    {
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/");
+      String _name = pc.getName();
+      _builder.append(_name);
+      _builder.append("/");
+      {
+        if (regular) {
+          _builder.append("regular");
+        } else {
+          _builder.append("conjugated");
+        }
+      }
+      _builder.append("/");
+      String _stringPath = this.toStringPath(path);
+      _builder.append(_stringPath);
+      String id = _builder.toString();
+      AttrClassConfig _get = this._dataConfigurationHelper.protocolClassAttrMap.get(id);
+      ConfigValueArray _value = null;
+      if (_get!=null) {
+        _value=_get.getValue();
+      }
+      String _stringExpr = null;
+      if (_value!=null) {
+        _stringExpr=this.toStringExpr(_value);
+      }
+      _xblockexpression = _stringExpr;
+    }
+    return _xblockexpression;
+  }
+  
+  private String toStringPath(final List<Attribute> path) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _hasElements = false;
+      for(final Attribute a : path) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate("/", "");
+        }
+        String _name = a.getName();
+        _builder.append(_name);
+      }
+    }
+    return _builder.toString();
+  }
+  
+  @Override
+  public String getAttrInstanceConfigValue(final ActorInstance ai, final List<Attribute> path) {
+    String _xblockexpression = null;
+    {
+      String _path = ai.getPath();
+      String _plus = (_path + "/");
+      String _stringPath = this.toStringPath(path);
+      String id = (_plus + _stringPath);
+      AttrInstanceConfig _get = this._dataConfigurationHelper.actorInstanceAttrMap.get(id);
+      ConfigValueArray _value = null;
+      if (_get!=null) {
+        _value=_get.getValue();
+      }
+      String _stringExpr = null;
+      if (_value!=null) {
+        _stringExpr=this.toStringExpr(_value);
+      }
+      _xblockexpression = _stringExpr;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getAttrInstanceConfigValue(final InterfaceItemInstance item, final List<Attribute> path) {
+    String _path = item.getPath();
+    String _plus = (_path + "/");
+    String _stringPath = this.toStringPath(path);
+    String _plus_1 = (_plus + _stringPath);
+    AttrInstanceConfig _get = this._dataConfigurationHelper.actorInstanceAttrMap.get(_plus_1);
+    ConfigValueArray _value = null;
+    if (_get!=null) {
+      _value=_get.getValue();
+    }
+    String _stringExpr = null;
+    if (_value!=null) {
+      _stringExpr=this.toStringExpr(_value);
+    }
+    return _stringExpr;
+  }
+  
+  @Override
+  public long getPollingTimerUser(final SubSystemInstance subsystem) {
+    long _xblockexpression = (long) 0;
+    {
+      SubSystemConfig _config = this.getConfig(subsystem);
+      DynamicConfig _dynConfig = null;
+      if (_config!=null) {
+        _dynConfig=_config.getDynConfig();
+      }
+      final DynamicConfig dynConf = _dynConfig;
+      long _xifexpression = (long) 0;
+      boolean _equals = Objects.equal(dynConf, null);
+      if (_equals) {
+        _xifexpression = 0;
+      } else {
+        _xifexpression = dynConf.getPolling();
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getUserCode1(final SubSystemInstance subsystem) {
+    SubSystemConfig _config = this.getConfig(subsystem);
+    DynamicConfig _dynConfig = null;
+    if (_config!=null) {
+      _dynConfig=_config.getDynConfig();
+    }
+    DynamicConfig dynConfig = _dynConfig;
+    String _xifexpression = null;
+    String _filePath = null;
+    if (dynConfig!=null) {
+      _filePath=dynConfig.getFilePath();
+    }
+    boolean _notEquals = (!Objects.equal(_filePath, null));
+    if (_notEquals) {
+      _xifexpression = "import org.eclipse.etrice.runtime.java.config.ConfigSourceFile;";
+    } else {
+      String _userCode1 = null;
+      if (dynConfig!=null) {
+        _userCode1=dynConfig.getUserCode1();
+      }
+      _xifexpression = _userCode1;
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String getUserCode2(final SubSystemInstance subsystem) {
+    SubSystemConfig _config = this.getConfig(subsystem);
+    DynamicConfig _dynConfig = null;
+    if (_config!=null) {
+      _dynConfig=_config.getDynConfig();
+    }
+    DynamicConfig dynConfig = _dynConfig;
+    String _xifexpression = null;
+    String _filePath = null;
+    if (dynConfig!=null) {
+      _filePath=dynConfig.getFilePath();
+    }
+    boolean _notEquals = (!Objects.equal(_filePath, null));
+    if (_notEquals) {
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("new ConfigSourceFile(\"");
+      String _filePath_1 = dynConfig.getFilePath();
+      _builder.append(_filePath_1);
+      _builder.append("\")");
+      _xifexpression = _builder.toString();
+    } else {
+      String _userCode2 = null;
+      if (dynConfig!=null) {
+        _userCode2=dynConfig.getUserCode2();
+      }
+      _xifexpression = _userCode2;
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public List<Attribute> getDynConfigReadAttributes(final ActorInstance ai) {
+    final ArrayList<Attribute> result = new ArrayList<Attribute>();
+    List<AttrInstanceConfig> configs = this._dataConfigurationHelper.dynActorInstanceAttrMap.get(ai.getPath());
+    if (configs!=null) {
+      final Consumer<AttrInstanceConfig> _function = (AttrInstanceConfig c) -> {
+        boolean _isReadOnly = c.isReadOnly();
+        if (_isReadOnly) {
+          result.add(c.getAttribute());
+        }
+      };
+      configs.forEach(_function);
+    }
+    return result;
+  }
+  
+  @Override
+  public List<Attribute> getDynConfigWriteAttributes(final ActorInstance ai) {
+    final ArrayList<Attribute> result = new ArrayList<Attribute>();
+    List<AttrInstanceConfig> configs = this._dataConfigurationHelper.dynActorInstanceAttrMap.get(ai.getPath());
+    if (configs!=null) {
+      final Consumer<AttrInstanceConfig> _function = (AttrInstanceConfig c) -> {
+        boolean _isReadOnly = c.isReadOnly();
+        boolean _not = (!_isReadOnly);
+        if (_not) {
+          result.add(c.getAttribute());
+        }
+      };
+      configs.forEach(_function);
+    }
+    return result;
+  }
+  
+  @Override
+  public boolean hasVariableService(final SubSystemInstance subsystem) {
+    SubSystemConfig _config = this.getConfig(subsystem);
+    DynamicConfig _dynConfig = null;
+    if (_config!=null) {
+      _dynConfig=_config.getDynConfig();
+    }
+    return (!Objects.equal(_dynConfig, null));
+  }
+  
+  private String toStringExpr(final ConfigValueArray literal) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<ConfigValue> _values = literal.getValues();
+      boolean _hasElements = false;
+      for(final ConfigValue l : _values) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(",", "");
+        }
+        String _stringExpr = this.toStringExpr(l);
+        _builder.append(_stringExpr);
+      }
+    }
+    return _builder.toString();
+  }
+  
+  private String toStringExpr(final ConfigValue configValue) {
+    String _switchResult = null;
+    boolean _matched = false;
+    if (configValue instanceof LiteralConfigValue) {
+      _matched=true;
+      _switchResult = this.toStringExpr(((LiteralConfigValue)configValue).getValue());
+    }
+    if (!_matched) {
+      if (configValue instanceof EnumConfigValue) {
+        _matched=true;
+        _switchResult = ((EnumConfigValue)configValue).getValue().getFullName();
+      }
+    }
+    return _switchResult;
+  }
+  
+  private String toStringExpr(final Literal literal) {
+    String _switchResult = null;
+    boolean _matched = false;
+    if (literal instanceof BooleanLiteral) {
+      _matched=true;
+      _switchResult = Boolean.valueOf(((BooleanLiteral)literal).isIsTrue()).toString();
+    }
+    if (!_matched) {
+      if (literal instanceof IntLiteral) {
+        _matched=true;
+        _switchResult = Long.valueOf(((IntLiteral)literal).getValue()).toString();
+      }
+    }
+    if (!_matched) {
+      if (literal instanceof RealLiteral) {
+        _matched=true;
+        _switchResult = Double.valueOf(((RealLiteral)literal).getValue()).toString();
+      }
+    }
+    if (!_matched) {
+      if (literal instanceof StringLiteral) {
+        _matched=true;
+        _switchResult = ((StringLiteral)literal).getValue().toString();
+      }
+    }
+    return _switchResult;
+  }
+  
+  private SubSystemConfig getConfig(final SubSystemInstance cc) {
+    return this._dataConfigurationHelper.subSystemConfigMap.get(cc.getPath());
+  }
+  
+  @Override
+  public List<Attribute> getDynConfigReadAttributes(final ActorClass actor) {
+    final HashSet<Attribute> result = new HashSet<Attribute>();
+    final List<AttrInstanceConfig> configs = this._dataConfigurationHelper.dynActorClassAttrMap.get(actor);
+    if (configs!=null) {
+      final Consumer<AttrInstanceConfig> _function = (AttrInstanceConfig c) -> {
+        boolean _isReadOnly = c.isReadOnly();
+        if (_isReadOnly) {
+          result.add(c.getAttribute());
+        }
+      };
+      configs.forEach(_function);
+    }
+    return IterableExtensions.<Attribute>toList(result);
+  }
+  
+  @Override
+  public List<Attribute> getDynConfigWriteAttributes(final ActorClass actor) {
+    final HashSet<Attribute> result = new HashSet<Attribute>();
+    final List<AttrInstanceConfig> configs = this._dataConfigurationHelper.dynActorClassAttrMap.get(actor);
+    if (configs!=null) {
+      final Consumer<AttrInstanceConfig> _function = (AttrInstanceConfig c) -> {
+        boolean _isReadOnly = c.isReadOnly();
+        boolean _not = (!_isReadOnly);
+        if (_not) {
+          result.add(c.getAttribute());
+        }
+      };
+      configs.forEach(_function);
+    }
+    return IterableExtensions.<Attribute>toList(result);
+  }
+}
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 c985f7177..01cec3227 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.1",
  org.eclipse.etrice.generator.doc;bundle-version="1.1.1",
  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..45ffd82ba 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,7 +24,7 @@ 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
@@ -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" }
@@ -219,9 +219,9 @@ 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]
 	}
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..16f5e98f1 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
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.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.java
new file mode 100644
index 000000000..39e1004cb
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ActorClassGen.java
@@ -0,0 +1,1094 @@
+/**
+ * Copyright (c) 2011 Draeger Medical GmbH (http://www.draeger.com).
+ * 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:
+ * 		Peter Karlitschek (initial contribution)
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+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.Wire;
+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.core.room.ActorRef;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.SAP;
+import org.eclipse.etrice.core.room.SPP;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.generator.cpp.Main;
+import org.eclipse.etrice.generator.cpp.gen.CppExtensions;
+import org.eclipse.etrice.generator.cpp.gen.Initialization;
+import org.eclipse.etrice.generator.cpp.gen.StateMachineGen;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.generic.GenericActorClassGenerator;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ActorClassGen extends GenericActorClassGenerator {
+  @Inject
+  protected IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  protected CppExtensions _cppExtensions;
+  
+  @Inject
+  @Extension
+  protected RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  protected ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  protected Initialization initHelper;
+  
+  @Inject
+  @Extension
+  protected StateMachineGen _stateMachineGen;
+  
+  @Inject
+  @Extension
+  protected FileSystemHelpers _fileSystemHelpers;
+  
+  public void doGenerate(final Root root) {
+    final Map<ActorClass, WiredActorClass> ac2wired = CollectionLiterals.<ActorClass, WiredActorClass>newHashMap();
+    final Consumer<WiredActorClass> _function = (WiredActorClass it) -> {
+      ac2wired.put(it.getActorClass(), it);
+    };
+    Iterables.<WiredActorClass>filter(root.getWiredInstances(), WiredActorClass.class).forEach(_function);
+    final Function1<ActorClass, Boolean> _function_1 = (ActorClass it) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(it));
+    };
+    final Function1<ActorClass, ExpandedActorClass> _function_2 = (ActorClass it) -> {
+      return root.getExpandedActorClass(it);
+    };
+    Iterable<ExpandedActorClass> _map = IterableExtensions.<ActorClass, ExpandedActorClass>map(IterableExtensions.<ActorClass>filter(root.getActorClasses(), _function_1), _function_2);
+    for (final ExpandedActorClass xpac : _map) {
+      {
+        final WiredActorClass wired = ac2wired.get(xpac.getActorClass());
+        final boolean manualBehavior = this._roomHelpers.isBehaviorAnnotationPresent(xpac.getActorClass(), "BehaviorManual");
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(xpac.getActorClass());
+        String _path = this._roomExtensions.getPath(xpac.getActorClass());
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(xpac.getActorClass());
+        String _path_1 = this._roomExtensions.getPath(xpac.getActorClass());
+        final String infopath = (_generationInfoPath + _path_1);
+        String _xifexpression = null;
+        if (manualBehavior) {
+          _xifexpression = "Abstract";
+        } else {
+          _xifexpression = "";
+        }
+        String file = _xifexpression;
+        String _cppHeaderFileName = this._cppExtensions.getCppHeaderFileName(xpac.getActorClass());
+        String _plus = (file + _cppHeaderFileName);
+        this.fileIO.generateFile("generating ActorClass declaration", path, infopath, _plus, this.generateHeaderFile(root, xpac, wired, manualBehavior));
+        String _cppSourceFileName = this._cppExtensions.getCppSourceFileName(xpac.getActorClass());
+        String _plus_1 = (file + _cppSourceFileName);
+        this.fileIO.generateFile("generating ActorClass implementation", path, infopath, _plus_1, this.generateSourceFile(root, xpac, wired, manualBehavior));
+      }
+    }
+  }
+  
+  protected CharSequence generateHeaderFile(final Root root, final ExpandedActorClass xpac, final WiredActorClass wired, final boolean manualBehavior) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      String _xifexpression = null;
+      if (manualBehavior) {
+        String _name = ac.getName();
+        _xifexpression = ("Abstract" + _name);
+      } else {
+        _xifexpression = ac.getName();
+      }
+      final String clsname = _xifexpression;
+      String _elvis = null;
+      ActorClass _actorBase = ac.getActorBase();
+      String _name_1 = null;
+      if (_actorBase!=null) {
+        _name_1=_actorBase.getName();
+      }
+      if (_name_1 != null) {
+        _elvis = _name_1;
+      } else {
+        _elvis = "etRuntime::ActorClassBase";
+      }
+      final String rtBaseClassName = _elvis;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Header File of ActorClass ");
+      _builder.append(clsname, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cppExtensions.generateIncludeGuardBegin(ac, "");
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"common/etDatatypesCpp.hpp\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/IRTObject.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/PortBase.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/ReplicatedActorClassBase.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/InterfaceItemBase.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/SubSystemClassBase.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/Address.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/IMessageReceiver.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/debugging/DebuggingService.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(ac);
+        for(final ProtocolClass pc : _referencedProtocolClasses) {
+          _builder.append("#include \"");
+          String _path = this._roomExtensions.getPath(pc);
+          _builder.append(_path);
+          String _name_2 = pc.getName();
+          _builder.append(_name_2);
+          _builder.append(".h\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(ac);
+        for(final DataClass dc : _referencedDataClasses) {
+          _builder.append("#include \"");
+          String _path_1 = this._roomExtensions.getPath(dc);
+          _builder.append(_path_1);
+          String _name_3 = dc.getName();
+          _builder.append(_name_3);
+          _builder.append(".h\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        ActorClass _actorBase_1 = ac.getActorBase();
+        boolean _equals = Objects.equal(_actorBase_1, null);
+        if (_equals) {
+          _builder.append("#include \"common/modelbase/ActorClassBase.h\"");
+          _builder.newLine();
+        } else {
+          _builder.append("#include \"");
+          String _path_2 = this._roomExtensions.getPath(ac.getActorBase());
+          _builder.append(_path_2);
+          String _name_4 = ac.getActorBase().getName();
+          _builder.append(_name_4);
+          _builder.append(".h\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<ActorRef> _actorRefs = ac.getActorRefs();
+        for(final ActorRef ar : _actorRefs) {
+          _builder.append("#include \"");
+          String _actorIncludePath = this._cppExtensions.getActorIncludePath(ar.getType());
+          _builder.append(_actorIncludePath);
+          _builder.append("\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(ac.getUserCode1());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("using namespace etRuntime;");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceBegin = this._cppExtensions.generateNamespaceBegin(ac);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("class ");
+      _builder.append(clsname);
+      _builder.append(" : public ");
+      _builder.append(rtBaseClassName);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- ports");
+      _builder.newLine();
+      {
+        List<Port> _endPorts = this._roomHelpers.getEndPorts(ac);
+        for(final Port ep : _endPorts) {
+          _builder.append("\t\t");
+          String _portClassName = this._roomExtensions.getPortClassName(ep);
+          _builder.append(_portClassName, "\t\t");
+          _builder.append(" ");
+          String _name_5 = ep.getName();
+          _builder.append(_name_5, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs_1 = ac.getActorRefs();
+        for(final ActorRef sub : _actorRefs_1) {
+          {
+            int _multiplicity = sub.getMultiplicity();
+            boolean _greaterThan = (_multiplicity > 1);
+            if (_greaterThan) {
+              _builder.append("\t\t");
+              _builder.append("Replicated");
+              String _implementationClassName = this._cppExtensions.getImplementationClassName(sub.getType());
+              _builder.append(_implementationClassName, "\t\t");
+              _builder.append(" ");
+              String _name_6 = sub.getName();
+              _builder.append(_name_6, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t\t");
+              String _implementationClassName_1 = this._cppExtensions.getImplementationClassName(sub.getType());
+              _builder.append(_implementationClassName_1, "\t\t");
+              _builder.append(" ");
+              String _name_7 = sub.getName();
+              _builder.append(_name_7, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- saps");
+      _builder.newLine();
+      {
+        EList<SAP> _serviceAccessPoints = ac.getServiceAccessPoints();
+        for(final SAP sap : _serviceAccessPoints) {
+          _builder.append("\t\t");
+          String _portClassName_1 = this._roomExtensions.getPortClassName(sap);
+          _builder.append(_portClassName_1, "\t\t");
+          _builder.append(" ");
+          String _name_8 = sap.getName();
+          _builder.append(_name_8, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- services");
+      _builder.newLine();
+      {
+        EList<ServiceImplementation> _serviceImplementations = ac.getServiceImplementations();
+        for(final ServiceImplementation svc : _serviceImplementations) {
+          _builder.append("\t\t");
+          String _portClassName_2 = this._roomExtensions.getPortClassName(svc);
+          _builder.append(_portClassName_2, "\t\t");
+          _builder.append(" ");
+          String _name_9 = svc.getSpp().getName();
+          _builder.append(_name_9, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- interface item IDs");
+      _builder.newLine();
+      _builder.append("\t\t");
+      String _genInterfaceItemConstants = this.genInterfaceItemConstants(xpac);
+      _builder.append(_genInterfaceItemConstants, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      CharSequence _attributes = this._procedureHelpers.attributes(ac.getAttributes());
+      _builder.append(_attributes, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      CharSequence _operationsDeclaration = this._procedureHelpers.operationsDeclaration(ac.getOperations(), ac.getName());
+      _builder.append(_operationsDeclaration, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- construction");
+      _builder.newLine();
+      _builder.append("\t\t");
+      String _name_10 = ac.getName();
+      _builder.append(_name_10, "\t\t");
+      _builder.append("(etRuntime::IRTObject* parent, const String& name);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("void initialize(void);");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t\t");
+          _builder.append("void setProbesActive(bool recursive, bool active);");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- port getters");
+      _builder.newLine();
+      _builder.append("\t\t");
+      final Function1<Port, CharSequence> _function = (Port it) -> {
+        String _portClassName_3 = this._roomExtensions.getPortClassName(it);
+        String _plus = (_portClassName_3 + "&");
+        return this._procedureHelpers.getterImplementation(_plus, it.getName(), clsname);
+      };
+      String _join = IterableExtensions.join(ListExtensions.<Port, CharSequence>map(this._roomHelpers.getEndPorts(ac), _function), this._roomExtensions.NEWLINE);
+      _builder.append(_join, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      final Function1<SAP, CharSequence> _function_1 = (SAP it) -> {
+        String _portClassName_3 = this._roomExtensions.getPortClassName(it);
+        String _plus = (_portClassName_3 + "&");
+        return this._procedureHelpers.getterImplementation(_plus, it.getName(), clsname);
+      };
+      String _join_1 = IterableExtensions.join(ListExtensions.<SAP, CharSequence>map(ac.getServiceAccessPoints(), _function_1), this._roomExtensions.NEWLINE);
+      _builder.append(_join_1, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      final Function1<ServiceImplementation, CharSequence> _function_2 = (ServiceImplementation it) -> {
+        String _portClassName_3 = this._roomExtensions.getPortClassName(it);
+        String _plus = (_portClassName_3 + "&");
+        return this._procedureHelpers.getterImplementation(_plus, it.getSpp().getName(), clsname);
+      };
+      String _join_2 = IterableExtensions.join(ListExtensions.<ServiceImplementation, CharSequence>map(ac.getServiceImplementations(), _function_2), this._roomExtensions.NEWLINE);
+      _builder.append(_join_2, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("//--------------------- lifecycle functions");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void destroy();");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _hasNonEmptyStateMachine = this._roomHelpers.hasNonEmptyStateMachine(ac);
+        if (_hasNonEmptyStateMachine) {
+          _builder.append("\t\t");
+          CharSequence _genStateMachineConstants = this._stateMachineGen.genStateMachineConstants(xpac.getGraphContainer());
+          _builder.append(_genStateMachineConstants, "\t\t");
+          _builder.newLineIfNotEmpty();
+          _builder.newLine();
+          _builder.append("\t\t");
+          CharSequence _genStateMachineMethods = this._stateMachineGen.genStateMachineMethods(xpac.getGraphContainer(), false);
+          _builder.append(_genStateMachineMethods, "\t\t");
+          _builder.newLineIfNotEmpty();
+          {
+            ComponentCommunicationType _commType = ac.getCommType();
+            boolean _equals_1 = Objects.equal(_commType, ComponentCommunicationType.DATA_DRIVEN);
+            if (_equals_1) {
+              _builder.append("\t\t");
+              _builder.append("void receiveEvent(etRuntime::InterfaceItemBase* ifitem, int evt, void* generic_data);");
+              _builder.newLine();
+            }
+          }
+          {
+            if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+              _builder.append("\t\t");
+              _builder.append("virtual void receive(const etRuntime::Message* msg);");
+              _builder.newLine();
+            }
+          }
+        } else {
+          boolean _isEmpty = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+          if (_isEmpty) {
+            _builder.append("\t\t");
+            _builder.append("//--------------------- no state machine");
+            _builder.newLine();
+            _builder.append("\t\t");
+            _builder.append("virtual void receiveEvent(etRuntime::InterfaceItemBase* ifitem, int evt, void* data);");
+            _builder.newLine();
+            _builder.append("\t\t");
+            _builder.append("virtual void executeInitTransition() {}");
+            _builder.newLine();
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(ac.getUserCode2());
+      _builder.append(_userCode_1, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("class Replicated");
+      _builder.append(clsname);
+      _builder.append(" : public ReplicatedActorClassBase {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("Replicated");
+      _builder.append(clsname, "\t");
+      _builder.append("(IRTObject* parent, const String& name) :");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("ReplicatedActorClassBase(parent, name) {}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("protected:");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ActorClassBase* createActor(IRTObject* parent, const String& name) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return new ");
+      _builder.append(clsname, "\t\t");
+      _builder.append("(parent, name);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceEnd = this._cppExtensions.generateNamespaceEnd(ac);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cppExtensions.generateIncludeGuardEnd(ac, "");
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateConstructorInitalizerList(final ActorClass ac) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      ArrayList<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      StringConcatenation _builder = new StringConcatenation();
+      String _elvis = null;
+      ActorClass _actorBase = ac.getActorBase();
+      String _name = null;
+      if (_actorBase!=null) {
+        _name=_actorBase.getName();
+      }
+      if (_name != null) {
+        _elvis = _name;
+      } else {
+        _elvis = "ActorClassBase";
+      }
+      _builder.append(_elvis);
+      _builder.append("(parent, name)");
+      initList.add(_builder.toString());
+      final Function1<Port, String> _function = (Port it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(this, \"");
+        String _name_2 = it.getName();
+        _builder_1.append(_name_2);
+        _builder_1.append("\", IFITEM_");
+        String _name_3 = it.getName();
+        _builder_1.append(_name_3);
+        _builder_1.append(")");
+        return _builder_1.toString();
+      };
+      List<String> _map = ListExtensions.<Port, String>map(this._roomHelpers.getEndPorts(ac), _function);
+      Iterables.<CharSequence>addAll(initList, _map);
+      final Function1<ActorRef, String> _function_1 = (ActorRef it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(this, \"");
+        String _name_2 = it.getName();
+        _builder_1.append(_name_2);
+        _builder_1.append("\")");
+        return _builder_1.toString();
+      };
+      List<String> _map_1 = ListExtensions.<ActorRef, String>map(ac.getActorRefs(), _function_1);
+      Iterables.<CharSequence>addAll(initList, _map_1);
+      final Function1<SAP, String> _function_2 = (SAP it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(this, \"");
+        String _name_2 = it.getName();
+        _builder_1.append(_name_2);
+        _builder_1.append("\", IFITEM_");
+        String _name_3 = it.getName();
+        _builder_1.append(_name_3);
+        _builder_1.append(")");
+        return _builder_1.toString();
+      };
+      List<String> _map_2 = ListExtensions.<SAP, String>map(ac.getServiceAccessPoints(), _function_2);
+      Iterables.<CharSequence>addAll(initList, _map_2);
+      final Function1<ServiceImplementation, String> _function_3 = (ServiceImplementation it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getSpp().getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(this, \"");
+        String _name_2 = it.getSpp().getName();
+        _builder_1.append(_name_2);
+        _builder_1.append("\", IFITEM_");
+        String _name_3 = it.getSpp().getName();
+        _builder_1.append(_name_3);
+        _builder_1.append(")");
+        return _builder_1.toString();
+      };
+      List<String> _map_3 = ListExtensions.<ServiceImplementation, String>map(ac.getServiceImplementations(), _function_3);
+      Iterables.<CharSequence>addAll(initList, _map_3);
+      final Function1<Attribute, String> _function_4 = (Attribute it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(");
+        String _initializerListValue = initHelper.getInitializerListValue(it);
+        _builder_1.append(_initializerListValue);
+        _builder_1.append(")");
+        return _builder_1.toString();
+      };
+      List<String> _map_4 = ListExtensions.<Attribute, String>map(ac.getAttributes(), _function_4);
+      Iterables.<CharSequence>addAll(initList, _map_4);
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence generateSourceFile(final Root root, final ExpandedActorClass xpac, final WiredActorClass wired, final boolean manualBehavior) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      String _xifexpression = null;
+      if (manualBehavior) {
+        String _name = ac.getName();
+        _xifexpression = ("Abstract" + _name);
+      } else {
+        _xifexpression = ac.getName();
+      }
+      final String clsname = _xifexpression;
+      String _elvis = null;
+      ActorClass _actorBase = ac.getActorBase();
+      String _name_1 = null;
+      if (_actorBase!=null) {
+        _name_1=_actorBase.getName();
+      }
+      if (_name_1 != null) {
+        _elvis = _name_1;
+      } else {
+        _elvis = "ActorClassBase";
+      }
+      final String rtBaseClassName = _elvis;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Source File of ActorClass ");
+      String _name_2 = ac.getName();
+      _builder.append(_name_2, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cppHeaderFileName = this._cppExtensions.getCppHeaderFileName(ac);
+      _builder.append(_cppHeaderFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/RTObject.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/RTServices.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/debugging/DebuggingService.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/debugging/MSCFunctionObject.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("using namespace etRuntime;");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceBegin = this._cppExtensions.generateNamespaceBegin(ac);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(ac.getUserCode3());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append(clsname);
+      _builder.append("::");
+      _builder.append(clsname);
+      _builder.append("(etRuntime::IRTObject* parent, const String& name)");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      CharSequence _generateConstructorInitalizerList = this.generateConstructorInitalizerList(ac);
+      _builder.append(_generateConstructorInitalizerList, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("{");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"Constructor\");");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        boolean _hasNonEmptyStateMachine = this._roomHelpers.hasNonEmptyStateMachine(ac);
+        if (_hasNonEmptyStateMachine) {
+          _builder.append("\t");
+          _builder.append("for (int i = 0; i < s_numberOfStates; i++) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("history[i] = NO_STATE;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("setClassName(\"");
+      String _name_3 = ac.getName();
+      _builder.append(_name_3, "\t");
+      _builder.append("\");");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs = ac.getActorRefs();
+        for(final ActorRef sub : _actorRefs) {
+          {
+            int _multiplicity = sub.getMultiplicity();
+            boolean _greaterThan = (_multiplicity > 1);
+            if (_greaterThan) {
+              _builder.append("\t");
+              String _name_4 = sub.getName();
+              _builder.append(_name_4, "\t");
+              _builder.append(".createSubActors(");
+              int _multiplicity_1 = sub.getMultiplicity();
+              _builder.append(_multiplicity_1, "\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _genExtraInitializers = this.initHelper.genExtraInitializers(ac.getAttributes());
+      _builder.append(_genExtraInitializers, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      String _userStructorBody = this._procedureHelpers.userStructorBody(ac, true);
+      _builder.append(_userStructorBody, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_5 = ac.getName();
+      _builder.append(_name_5);
+      _builder.append("::initialize() {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"initialize()\");");
+          _builder.newLine();
+          {
+            EList<ActorRef> _actorRefs_1 = ac.getActorRefs();
+            for(final ActorRef sub_1 : _actorRefs_1) {
+              {
+                int _multiplicity_2 = sub_1.getMultiplicity();
+                boolean _greaterThan_1 = (_multiplicity_2 > 1);
+                if (_greaterThan_1) {
+                  _builder.append("\t");
+                  _builder.append("for (int i=0; i<");
+                  int _multiplicity_3 = sub_1.getMultiplicity();
+                  _builder.append(_multiplicity_3, "\t");
+                  _builder.append("; ++i) {");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("DebuggingService::getInstance().addMessageActorCreate(*this, ");
+                  String _name_6 = sub_1.getName();
+                  _builder.append(_name_6, "\t\t");
+                  _builder.append(".getSubActor(i)->getName());");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("}");
+                  _builder.newLine();
+                } else {
+                  _builder.append("\t");
+                  _builder.append("DebuggingService::getInstance().addMessageActorCreate(*this, \"");
+                  String _name_7 = sub_1.getName();
+                  _builder.append(_name_7, "\t");
+                  _builder.append("\");");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("ActorClassBase::initialize();");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs_2 = ac.getActorRefs();
+        for(final ActorRef sub_2 : _actorRefs_2) {
+          _builder.append("\t");
+          String _name_8 = sub_2.getName();
+          _builder.append(_name_8, "\t");
+          _builder.append(".initialize();");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// wiring");
+      _builder.newLine();
+      {
+        EList<Wire> _wires = wired.getWires();
+        for(final Wire wire : _wires) {
+          _builder.append("\t");
+          String _xifexpression_1 = null;
+          boolean _isDataDriven = wire.isDataDriven();
+          if (_isDataDriven) {
+            _xifexpression_1 = "DataPortBase";
+          } else {
+            _xifexpression_1 = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression_1, "\t");
+          _builder.append("::connect(this, \"");
+          String _join = IterableExtensions.join(wire.getPath1(), "/");
+          _builder.append(_join, "\t");
+          _builder.append("\", \"");
+          String _join_1 = IterableExtensions.join(wire.getPath2(), "/");
+          _builder.append(_join_1, "\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+          _builder.append("\t");
+          _builder.append("// activate polling for data-driven communication");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("RTServices::getInstance().getMsgSvcCtrl().getMsgSvc(getThread())->addPollingMessageReceiver(*this);");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_2) {
+          _builder.append("void ");
+          String _name_9 = ac.getName();
+          _builder.append(_name_9);
+          _builder.append("::setProbesActive(bool recursive, bool active) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().addPortInstance(m_RTSystemPort);");
+          _builder.newLine();
+          {
+            int _size = ac.getActorRefs().size();
+            boolean _greaterThan_2 = (_size > 0);
+            if (_greaterThan_2) {
+              _builder.append("\t");
+              _builder.append("if(recursive) {");
+              _builder.newLine();
+              {
+                EList<ActorRef> _actorRefs_3 = ac.getActorRefs();
+                for(final ActorRef sub_3 : _actorRefs_3) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  String _name_10 = sub_3.getName();
+                  _builder.append(_name_10, "\t\t");
+                  _builder.append(".setProbesActive(recursive, active);");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          {
+            List<Port> _endPorts = this._roomHelpers.getEndPorts(ac);
+            for(final Port ep : _endPorts) {
+              {
+                boolean _isDataDriven_1 = this._roomHelpers.isDataDriven(ep);
+                boolean _not = (!_isDataDriven_1);
+                if (_not) {
+                  {
+                    boolean _isReplicated = ep.isReplicated();
+                    if (_isReplicated) {
+                      _builder.append("\t");
+                      _builder.append("for(int i = 0; i < ");
+                      String _name_11 = ep.getName();
+                      _builder.append(_name_11, "\t");
+                      _builder.append(".getNInterfaceItems(); i++)");
+                      _builder.newLineIfNotEmpty();
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("DebuggingService::getInstance().addPortInstance(*(");
+                      String _name_12 = ep.getName();
+                      _builder.append(_name_12, "\t\t");
+                      _builder.append(".getInterfaceItem(i)));");
+                      _builder.newLineIfNotEmpty();
+                    } else {
+                      _builder.append("\t");
+                      _builder.append("DebuggingService::getInstance().addPortInstance(");
+                      String _name_13 = ep.getName();
+                      _builder.append(_name_13, "\t");
+                      _builder.append(");");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                }
+              }
+            }
+          }
+          {
+            EList<SAP> _serviceAccessPoints = ac.getServiceAccessPoints();
+            for(final SAP sap : _serviceAccessPoints) {
+              _builder.append("\t");
+              _builder.append("DebuggingService::getInstance().addPortInstance(");
+              String _name_14 = sap.getName();
+              _builder.append(_name_14, "\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          {
+            EList<SPP> _serviceProvisionPoints = ac.getServiceProvisionPoints();
+            for(final SPP spp : _serviceProvisionPoints) {
+              _builder.append("\t");
+              _builder.append("for(int i = 0; i < ");
+              String _name_15 = spp.getName();
+              _builder.append(_name_15, "\t");
+              _builder.append(".getNInterfaceItems(); i++)");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("DebuggingService::getInstance().addPortInstance(*(");
+              String _name_16 = spp.getName();
+              _builder.append(_name_16, "\t\t\t");
+              _builder.append(".getInterfaceItem(i)));");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      String _name_17 = ac.getName();
+      _builder.append(_name_17);
+      _builder.append("::destroy(){");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation_3 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_3) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"destroy()\");");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      String _userStructorBody_1 = this._procedureHelpers.userStructorBody(ac, false);
+      _builder.append(_userStructorBody_1, "\t");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation_4 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_4) {
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().addMessageActorDestroy(*this);");
+          _builder.newLine();
+        }
+      }
+      {
+        if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+          _builder.append("\t");
+          _builder.append("RTServices::getInstance().getMsgSvcCtrl().getMsgSvc(getThread())->removePollingMessageReceiver(*this);");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append(rtBaseClassName, "\t");
+      _builder.append("::destroy();");
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(ac.getOperations(), ac.getName());
+      _builder.append(_operationsImplementation);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        boolean _hasNonEmptyStateMachine_1 = this._roomHelpers.hasNonEmptyStateMachine(ac);
+        if (_hasNonEmptyStateMachine_1) {
+          CharSequence _genStateMachineMethods = this._stateMachineGen.genStateMachineMethods(xpac.getGraphContainer(), true);
+          _builder.append(_genStateMachineMethods);
+          _builder.newLineIfNotEmpty();
+          {
+            ComponentCommunicationType _commType = ac.getCommType();
+            boolean _equals = Objects.equal(_commType, ComponentCommunicationType.DATA_DRIVEN);
+            if (_equals) {
+              _builder.append("void ");
+              String _name_18 = ac.getName();
+              _builder.append(_name_18);
+              _builder.append("::receiveEvent(InterfaceItemBase* ifitem, int evt, void* generic_data) {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("handleSystemEvent(ifitem, evt, generic_data);");
+              _builder.newLine();
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          {
+            if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+              _builder.append("void ");
+              String _name_19 = ac.getName();
+              _builder.append(_name_19);
+              _builder.append("::receive(const Message* msg) {");
+              _builder.newLineIfNotEmpty();
+              {
+                ComponentCommunicationType _commType_1 = ac.getCommType();
+                boolean _equals_1 = Objects.equal(_commType_1, ComponentCommunicationType.ASYNCHRONOUS);
+                if (_equals_1) {
+                  _builder.append("\t");
+                  _builder.append("receiveEvent(0, -1, 0);");
+                  _builder.newLine();
+                } else {
+                  _builder.append("\t");
+                  _builder.append("receiveEventInternal();");
+                  _builder.newLine();
+                }
+              }
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        } else {
+          boolean _isEmpty = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+          if (_isEmpty) {
+            _builder.append("//--------------------- no state machine");
+            _builder.newLine();
+            _builder.append("void ");
+            String _name_20 = ac.getName();
+            _builder.append(_name_20);
+            _builder.append("::receiveEvent(InterfaceItemBase* ifitem, int evt, void* data) {");
+            _builder.newLineIfNotEmpty();
+            _builder.append("\t");
+            _builder.append("handleSystemEvent(ifitem, evt, data);");
+            _builder.newLine();
+            _builder.append("}");
+            _builder.newLine();
+          }
+        }
+      }
+      _builder.newLine();
+      String _generateNamespaceEnd = this._cppExtensions.generateNamespaceEnd(ac);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ConfigGenAddon.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ConfigGenAddon.java
new file mode 100644
index 000000000..d29b527d7
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ConfigGenAddon.java
@@ -0,0 +1,525 @@
+/**
+ * Copyright (c) 2012 Juergen Haug
+ * 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
+ * 		Peter Karlitschek
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+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.ExternalType;
+import org.eclipse.etrice.core.room.PortClass;
+import org.eclipse.etrice.core.room.PrimitiveType;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+import org.eclipse.etrice.generator.cpp.gen.CppExtensions;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+public class ConfigGenAddon {
+  @Inject
+  @Extension
+  private CppExtensions stdExt;
+  
+  @Inject
+  @Extension
+  private TypeHelpers typeHelpers;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers helpers;
+  
+  @Inject
+  private IDataConfiguration dataConfigExt;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  public CharSequence genActorInstanceConfig(final ActorInstance ai, final String aiVariableName) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(ai.getActorClass());
+      for(final Attribute a : _allAttributes) {
+        String _applyInstanceConfig = this.applyInstanceConfig(ai, aiVariableName, this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a));
+        _builder.append(_applyInstanceConfig);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    {
+      EList<InterfaceItemInstance> _orderedIfItemInstances = ai.getOrderedIfItemInstances();
+      for(final InterfaceItemInstance pi : _orderedIfItemInstances) {
+        PortClass _portClass = this._roomHelpers.getPortClass(pi.getInterfaceItem());
+        EList<Attribute> _attributes = null;
+        if (_portClass!=null) {
+          _attributes=_portClass.getAttributes();
+        }
+        EList<Attribute> attribs = _attributes;
+        _builder.newLineIfNotEmpty();
+        {
+          boolean _notEquals = (!Objects.equal(attribs, null));
+          if (_notEquals) {
+            {
+              for(final Attribute a_1 : attribs) {
+                CharSequence _invokeGetter = this.helpers.invokeGetter(pi.getName(), null);
+                String _plus = ((aiVariableName + ".") + _invokeGetter);
+                String _applyInstanceConfig_1 = this.applyInstanceConfig(pi, _plus, this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a_1));
+                _builder.append(_applyInstanceConfig_1);
+                _builder.newLineIfNotEmpty();
+              }
+            }
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+  
+  private String applyInstanceConfig(final InstanceBase instance, final String invokes, final List<Attribute> path) {
+    String _xblockexpression = null;
+    {
+      Attribute a = IterableExtensions.<Attribute>last(path);
+      DataType aType = a.getType().getType();
+      String _xifexpression = null;
+      boolean _isPrimitive = this.typeHelpers.isPrimitive(aType);
+      if (_isPrimitive) {
+        String _xblockexpression_1 = null;
+        {
+          String value = this.typeHelpers.getAttrInstanceConfigValue(path, instance);
+          String _xifexpression_1 = null;
+          boolean _equals = Objects.equal(value, null);
+          if (_equals) {
+            StringConcatenation _builder = new StringConcatenation();
+            _xifexpression_1 = _builder.toString();
+          } else {
+            String _xifexpression_2 = null;
+            if (((a.getSize() == 0) || this.typeHelpers.isCharacterType(aType))) {
+              StringConcatenation _builder_1 = new StringConcatenation();
+              _builder_1.append(invokes);
+              _builder_1.append(".");
+              CharSequence _invokeSetter = this.helpers.invokeSetter(a.getName(), null, this.stdExt.toValueLiteral(((PrimitiveType) aType), value));
+              _builder_1.append(_invokeSetter);
+              _builder_1.append(";");
+              _xifexpression_2 = _builder_1.toString();
+            } else {
+              String _xifexpression_3 = null;
+              int _size = a.getSize();
+              int _size_1 = ((List<String>)Conversions.doWrapArray(value.split(","))).size();
+              boolean _equals_1 = (_size == _size_1);
+              if (_equals_1) {
+                String _xblockexpression_2 = null;
+                {
+                  StringConcatenation _builder_2 = new StringConcatenation();
+                  _builder_2.append("{ ");
+                  {
+                    String[] _split = value.split(",");
+                    boolean _hasElements = false;
+                    for(final String s : _split) {
+                      if (!_hasElements) {
+                        _hasElements = true;
+                      } else {
+                        _builder_2.appendImmediate(", ", "");
+                      }
+                      String _valueLiteral = this.stdExt.toValueLiteral(((PrimitiveType) aType), s.trim());
+                      _builder_2.append(_valueLiteral);
+                    }
+                  }
+                  _builder_2.append(" }");
+                  String arrayExpr = _builder_2.toString();
+                  StringConcatenation _builder_3 = new StringConcatenation();
+                  _builder_3.append(invokes);
+                  _builder_3.append(".");
+                  StringConcatenation _builder_4 = new StringConcatenation();
+                  _builder_4.append("new ");
+                  String _typeName = this.typeHelpers.typeName(aType);
+                  _builder_4.append(_typeName);
+                  _builder_4.append("[] ");
+                  _builder_4.append(arrayExpr);
+                  CharSequence _invokeSetter_1 = this.helpers.invokeSetter(a.getName(), null, _builder_4.toString());
+                  _builder_3.append(_invokeSetter_1);
+                  _builder_3.append(";");
+                  _xblockexpression_2 = _builder_3.toString();
+                }
+                _xifexpression_3 = _xblockexpression_2;
+              } else {
+                StringConcatenation _builder_2 = new StringConcatenation();
+                _builder_2.append("{");
+                _builder_2.newLine();
+                _builder_2.append("\t");
+                String _typeName = this.typeHelpers.typeName(aType);
+                _builder_2.append(_typeName, "\t");
+                _builder_2.append("[] array = ");
+                _builder_2.append(invokes, "\t");
+                _builder_2.append(".");
+                CharSequence _invokeGetter = this.helpers.invokeGetter(a.getName(), null);
+                _builder_2.append(_invokeGetter, "\t");
+                _builder_2.append(";");
+                _builder_2.newLineIfNotEmpty();
+                _builder_2.append("\t");
+                _builder_2.append("for (int i=0;i<");
+                int _size_2 = a.getSize();
+                _builder_2.append(_size_2, "\t");
+                _builder_2.append(";i++){");
+                _builder_2.newLineIfNotEmpty();
+                _builder_2.append("\t\t");
+                _builder_2.append("array[i] = ");
+                String _valueLiteral = this.stdExt.toValueLiteral(((PrimitiveType) aType), value);
+                _builder_2.append(_valueLiteral, "\t\t");
+                _builder_2.append(";");
+                _builder_2.newLineIfNotEmpty();
+                _builder_2.append("}");
+                _xifexpression_3 = _builder_2.toString();
+              }
+              _xifexpression_2 = _xifexpression_3;
+            }
+            _xifexpression_1 = _xifexpression_2;
+          }
+          _xblockexpression_1 = _xifexpression_1;
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        String _xifexpression_1 = null;
+        boolean _isDataClass = this.typeHelpers.isDataClass(aType);
+        if (_isDataClass) {
+          StringConcatenation _builder = new StringConcatenation();
+          {
+            EList<Attribute> _attributes = ((DataClass) aType).getAttributes();
+            for(final Attribute e : _attributes) {
+              CharSequence _invokeGetter = this.helpers.invokeGetter(a.getName(), null);
+              String _plus = ((invokes + ".") + _invokeGetter);
+              String _applyInstanceConfig = this.applyInstanceConfig(instance, _plus, this._roomExtensions.<Attribute>union(path, e));
+              _builder.append(_applyInstanceConfig);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _xifexpression_1 = _builder.toString();
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence genDynConfigGetterSetter(final ActorClass ac) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      List<Attribute> _dynConfigReadAttributes = this.dataConfigExt.getDynConfigReadAttributes(ac);
+      for(final Attribute a : _dynConfigReadAttributes) {
+        _builder.append("public ");
+        String _typeName = this.typeHelpers.typeName(a.getType().getType());
+        _builder.append(_typeName);
+        {
+          int _size = a.getSize();
+          boolean _greaterThan = (_size > 0);
+          if (_greaterThan) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" get");
+        String _firstUpper = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper);
+        _builder.append("(){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("if(lock_");
+        String _name = a.getName();
+        _builder.append(_name, "\t");
+        _builder.append(" == null)");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("return ");
+        String _name_1 = a.getName();
+        _builder.append(_name_1, "\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("else");
+        _builder.newLine();
+        _builder.append("\t\t");
+        _builder.append("synchronized(lock_");
+        String _name_2 = a.getName();
+        _builder.append(_name_2, "\t\t");
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t\t");
+        _builder.append("return ");
+        String _name_3 = a.getName();
+        _builder.append(_name_3, "\t\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("public void set");
+        String _firstUpper_1 = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper_1);
+        _builder.append("(");
+        String _typeName_1 = this.typeHelpers.typeName(a.getType().getType());
+        _builder.append(_typeName_1);
+        {
+          int _size_1 = a.getSize();
+          boolean _greaterThan_1 = (_size_1 > 0);
+          if (_greaterThan_1) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" ");
+        String _name_4 = a.getName();
+        _builder.append(_name_4);
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("if(lock_");
+        String _name_5 = a.getName();
+        _builder.append(_name_5, "\t");
+        _builder.append(" == null)");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("this.");
+        String _name_6 = a.getName();
+        _builder.append(_name_6, "\t\t");
+        _builder.append(" = ");
+        String _name_7 = a.getName();
+        _builder.append(_name_7, "\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("else");
+        _builder.newLine();
+        _builder.append("\t\t");
+        _builder.append("synchronized(lock_");
+        String _name_8 = a.getName();
+        _builder.append(_name_8, "\t\t");
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t\t");
+        _builder.append("this.");
+        String _name_9 = a.getName();
+        _builder.append(_name_9, "\t\t\t");
+        _builder.append(" = ");
+        String _name_10 = a.getName();
+        _builder.append(_name_10, "\t\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("public DynConfigLock get");
+        String _firstUpper_2 = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper_2);
+        _builder.append("Lock(){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("return lock_");
+        String _name_11 = a.getName();
+        _builder.append(_name_11, "\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}\t");
+        _builder.newLine();
+      }
+    }
+    {
+      List<Attribute> _dynConfigWriteAttributes = this.dataConfigExt.getDynConfigWriteAttributes(ac);
+      for(final Attribute a_1 : _dynConfigWriteAttributes) {
+        _builder.append("public void setAndWrite");
+        String _firstUpper_3 = StringExtensions.toFirstUpper(a_1.getName());
+        _builder.append(_firstUpper_3);
+        _builder.append("(");
+        String _typeName_2 = this.typeHelpers.typeName(a_1.getType().getType());
+        _builder.append(_typeName_2);
+        {
+          int _size_2 = a_1.getSize();
+          boolean _greaterThan_2 = (_size_2 > 0);
+          if (_greaterThan_2) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" ");
+        String _name_12 = a_1.getName();
+        _builder.append(_name_12);
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("set");
+        String _firstUpper_4 = StringExtensions.toFirstUpper(a_1.getName());
+        _builder.append(_firstUpper_4, "\t\t");
+        _builder.append("(");
+        String _name_13 = a_1.getName();
+        _builder.append(_name_13, "\t\t");
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("variableService.write(this.getInstancePath()+\"/");
+        String _name_14 = a_1.getName();
+        _builder.append(_name_14, "\t\t");
+        _builder.append("\", ");
+        String _name_15 = a_1.getName();
+        _builder.append(_name_15, "\t\t");
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  public String genMinMaxConstants(final ActorClass ac) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<Attribute> _attributes = ac.getAttributes();
+      for(final Attribute a : _attributes) {
+        String _genMinMaxConstantsRec = this.genMinMaxConstantsRec(ac, a.getName(), this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a));
+        _builder.append(_genMinMaxConstantsRec);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    String result = _builder.toString();
+    int _length = result.length();
+    boolean _notEquals = (_length != 0);
+    if (_notEquals) {
+      StringConcatenation _builder_1 = new StringConcatenation();
+      _builder_1.append("//--------------------- Attribute Specifications");
+      String _plus = (result + _builder_1);
+      result = _plus;
+    }
+    return result;
+  }
+  
+  private String genMinMaxConstantsRec(final ActorClass ac, final String varNamePath, final List<Attribute> path) {
+    String _xblockexpression = null;
+    {
+      String temp = ((String) null);
+      String _xifexpression = null;
+      boolean _isDataClass = this.typeHelpers.isDataClass(IterableExtensions.<Attribute>last(path).getType().getType());
+      if (_isDataClass) {
+        StringConcatenation _builder = new StringConcatenation();
+        {
+          DataType _type = IterableExtensions.<Attribute>last(path).getType().getType();
+          List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(((DataClass) _type));
+          for(final Attribute e : _allAttributes) {
+            String _name = e.getName();
+            String _plus = ((varNamePath + "_") + _name);
+            String _genMinMaxConstantsRec = this.genMinMaxConstantsRec(ac, _plus, this._roomExtensions.<Attribute>union(path, e));
+            _builder.append(_genMinMaxConstantsRec);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _xifexpression = _builder.toString();
+      } else {
+        String _xifexpression_1 = null;
+        DataType _type_1 = IterableExtensions.<Attribute>last(path).getType().getType();
+        if ((_type_1 instanceof ExternalType)) {
+          _xifexpression_1 = null;
+        } else {
+          String _xifexpression_2 = null;
+          DataType _type_2 = IterableExtensions.<Attribute>last(path).getType().getType();
+          if ((_type_2 instanceof EnumerationType)) {
+            _xifexpression_2 = null;
+          } else {
+            String _xblockexpression_1 = null;
+            {
+              DataType _type_3 = IterableExtensions.<Attribute>last(path).getType().getType();
+              PrimitiveType aType = ((PrimitiveType) _type_3);
+              StringConcatenation _builder_1 = new StringConcatenation();
+              {
+                boolean _notEquals = (!Objects.equal((temp = this.dataConfigExt.getAttrClassConfigMinValue(ac, path)), null));
+                if (_notEquals) {
+                  _builder_1.append("public static ");
+                  String _minMaxType = this.getMinMaxType(aType);
+                  _builder_1.append(_minMaxType);
+                  _builder_1.append(" MIN_");
+                  _builder_1.append(varNamePath);
+                  _builder_1.append(" = ");
+                  String _valueLiteral = this.stdExt.toValueLiteral(aType, temp);
+                  _builder_1.append(_valueLiteral);
+                  _builder_1.append(";");
+                  _builder_1.newLineIfNotEmpty();
+                }
+              }
+              {
+                boolean _notEquals_1 = (!Objects.equal((temp = this.dataConfigExt.getAttrClassConfigMaxValue(ac, path)), null));
+                if (_notEquals_1) {
+                  _builder_1.append("public static ");
+                  String _minMaxType_1 = this.getMinMaxType(aType);
+                  _builder_1.append(_minMaxType_1);
+                  _builder_1.append(" MAX_");
+                  _builder_1.append(varNamePath);
+                  _builder_1.append(" = ");
+                  String _valueLiteral_1 = this.stdExt.toValueLiteral(aType, temp);
+                  _builder_1.append(_valueLiteral_1);
+                  _builder_1.append(";");
+                  _builder_1.newLineIfNotEmpty();
+                }
+              }
+              _xblockexpression_1 = _builder_1.toString();
+            }
+            _xifexpression_2 = _xblockexpression_1;
+          }
+          _xifexpression_1 = _xifexpression_2;
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getMinMaxType(final PrimitiveType type) {
+    String _switchResult = null;
+    String _typeName = this.typeHelpers.typeName(type);
+    if (_typeName != null) {
+      switch (_typeName) {
+        case "byte":
+          _switchResult = "int";
+          break;
+        case "short":
+          _switchResult = "int";
+          break;
+        case "float":
+          _switchResult = "double";
+          break;
+        default:
+          _switchResult = this.typeHelpers.typeName(type);
+          break;
+      }
+    } else {
+      _switchResult = this.typeHelpers.typeName(type);
+    }
+    return _switchResult;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/CppExtensions.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/CppExtensions.java
new file mode 100644
index 000000000..079407806
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/CppExtensions.java
@@ -0,0 +1,581 @@
+/**
+ * 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)
+ * 		Peter Karlitschek
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.Collections;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.common.base.KeyValue;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.genmodel.etricegen.SubSystemInstance;
+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.PrimitiveType;
+import org.eclipse.etrice.core.room.RefableType;
+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.fsm.generic.ILanguageExtensionBase;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.util.Strings;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class CppExtensions implements ILanguageExtension {
+  @Inject
+  private IDiagnostician diagnostician;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Override
+  public String getTypedDataDefinition(final EObject msg) {
+    return this.generateArglistAndTypedData(((Message) msg).getData())[ILanguageExtensionBase.TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal()];
+  }
+  
+  public String getCppHeaderFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".h");
+  }
+  
+  public String getCppSourceFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".cpp");
+  }
+  
+  public String getCppClassName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = ("Node_" + _name);
+    String _plus_1 = (_plus + "_");
+    String _name_1 = ssi.getName();
+    return (_plus_1 + _name_1);
+  }
+  
+  public String getCppHeaderFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _cppClassName = this.getCppClassName(nr, ssi);
+    return (_cppClassName + ".h");
+  }
+  
+  public String getCppSourceFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _cppClassName = this.getCppClassName(nr, ssi);
+    return (_cppClassName + ".cpp");
+  }
+  
+  @Override
+  public String accessLevelPrivate() {
+    return "";
+  }
+  
+  @Override
+  public String accessLevelProtected() {
+    return "";
+  }
+  
+  @Override
+  public String accessLevelPublic() {
+    return "";
+  }
+  
+  @Override
+  public String memberAccess() {
+    return "this->";
+  }
+  
+  @Override
+  public String selfPointer(final String classname, final boolean hasArgs) {
+    return "";
+  }
+  
+  @Override
+  public String selfPointer(final boolean hasArgs) {
+    return "";
+  }
+  
+  @Override
+  public String scopeSeparator() {
+    return "::";
+  }
+  
+  @Override
+  public String operationScope(final String classname, final boolean isDeclaration) {
+    String _xifexpression = null;
+    if (isDeclaration) {
+      _xifexpression = "";
+    } else {
+      _xifexpression = (classname + "::");
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String memberInDeclaration(final String namespace, final String member) {
+    return member;
+  }
+  
+  @Override
+  public String memberInUse(final String namespace, final String member) {
+    return ((namespace + ".") + member);
+  }
+  
+  @Override
+  public boolean usesInheritance() {
+    return true;
+  }
+  
+  @Override
+  public boolean usesPointers() {
+    return true;
+  }
+  
+  @Override
+  public String genEnumeration(final String name, final List<Pair<String, String>> entries) {
+    String _xblockexpression = null;
+    {
+      boolean _isEmpty = entries.isEmpty();
+      if (_isEmpty) {
+        return "";
+      }
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("typedef enum {");
+      _builder.newLine();
+      {
+        boolean _hasElements = false;
+        for(final Pair<String, String> entry : entries) {
+          if (!_hasElements) {
+            _hasElements = true;
+          } else {
+            _builder.appendImmediate(",", "\t");
+          }
+          _builder.append("\t");
+          String _first = entry.getFirst();
+          _builder.append(_first, "\t");
+          _builder.append(" = ");
+          String _second = entry.getSecond();
+          _builder.append(_second, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("} ");
+      _builder.append(name);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String booleanConstant(final boolean b) {
+    return Boolean.valueOf(b).toString();
+  }
+  
+  @Override
+  public String pointerLiteral() {
+    return "*";
+  }
+  
+  @Override
+  public String nullPointer() {
+    return "0";
+  }
+  
+  @Override
+  public String voidPointer() {
+    return "void*";
+  }
+  
+  @Override
+  public String arrayType(final String type, final int size, final boolean isRef) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("StaticArray<");
+    _builder.append(type);
+    {
+      if (isRef) {
+        _builder.append("*");
+      }
+    }
+    _builder.append(", ");
+    _builder.append(size);
+    _builder.append(">");
+    return _builder.toString();
+  }
+  
+  @Override
+  public String arrayDeclaration(final String type, final int size, final boolean isRef, final String name) {
+    String _arrayType = this.arrayType(type, size, isRef);
+    String _plus = (_arrayType + " ");
+    return (_plus + name);
+  }
+  
+  public String getIncludeGuardString(final RoomClass roomClass, final String appendSegments) {
+    String[] _split = this._roomExtensions.getPackage(roomClass).split("\\.");
+    String _name = roomClass.getName();
+    Iterable<String> _plus = Iterables.<String>concat(((Iterable<? extends String>)Conversions.doWrapArray(_split)), Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList(_name)));
+    String[] _split_1 = appendSegments.split("\\.");
+    final Function1<String, Boolean> _function = (String it) -> {
+      boolean _isEmpty = it.isEmpty();
+      return Boolean.valueOf((!_isEmpty));
+    };
+    String _upperCase = IterableExtensions.join(IterableExtensions.<String>filter(Iterables.<String>concat(_plus, ((Iterable<? extends String>)Conversions.doWrapArray(_split_1))), _function), "_").toUpperCase();
+    String _plus_1 = ("_" + _upperCase);
+    return (_plus_1 + "_H_");
+  }
+  
+  public CharSequence generateIncludeGuardBegin(final RoomClass roomClass, final String appendSegments) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("#ifndef ");
+    String _includeGuardString = this.getIncludeGuardString(roomClass, appendSegments);
+    _builder.append(_includeGuardString);
+    _builder.newLineIfNotEmpty();
+    _builder.append("#define ");
+    String _includeGuardString_1 = this.getIncludeGuardString(roomClass, appendSegments);
+    _builder.append(_includeGuardString_1);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  public CharSequence generateIncludeGuardEnd(final RoomClass roomClass, final String appendSegments) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("#endif /* ");
+    String _includeGuardString = this.getIncludeGuardString(roomClass, appendSegments);
+    _builder.append(_includeGuardString);
+    _builder.append(" */");
+    return _builder;
+  }
+  
+  public String generateNamespaceBegin(final RoomClass roomClass) {
+    return "";
+  }
+  
+  public String generateNamespaceEnd(final RoomClass roomClass) {
+    return "";
+  }
+  
+  @Override
+  public String superCall(final String baseClassName, final String method, final String arguments) {
+    return (((((baseClassName + "::") + method) + "(") + arguments) + ");");
+  }
+  
+  @Override
+  public String toValueLiteral(final PrimitiveType type, final String value) {
+    throw new UnsupportedOperationException("TODO Config for Cpp");
+  }
+  
+  @Override
+  public String toEnumLiteral(final EnumerationType type, final String value) {
+    throw new UnsupportedOperationException("TODO Config for Cpp");
+  }
+  
+  @Override
+  public String defaultValue(final DataType dt) {
+    String _switchResult = null;
+    final DataType it = dt;
+    boolean _matched = false;
+    if (it instanceof PrimitiveType) {
+      _matched=true;
+      _switchResult = ((PrimitiveType)it).getDefaultValueLiteral();
+    }
+    if (!_matched) {
+      if (it instanceof EnumerationType) {
+        _matched=true;
+        String _xblockexpression = null;
+        {
+          this.diagnostician.error("Enumeration not supported", dt, null);
+          _xblockexpression = "/* TODO */";
+        }
+        _switchResult = _xblockexpression;
+      }
+    }
+    if (!_matched) {
+      if (it instanceof ExternalType) {
+        _matched=true;
+        _switchResult = ((ExternalType)it).getDefaultValueLiteral();
+      }
+    }
+    return _switchResult;
+  }
+  
+  public String getDefaultValue(final EnumerationType type) {
+    String _xifexpression = null;
+    boolean _isEmpty = type.getLiterals().isEmpty();
+    if (_isEmpty) {
+      _xifexpression = "";
+    } else {
+      _xifexpression = this.getCastedValue(type.getLiterals().get(0));
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String initializationWithDefaultValues(final DataType dt, final int size) {
+    String _xblockexpression = null;
+    {
+      final String dv = this.defaultValue(dt);
+      String _xifexpression = null;
+      if ((size > 1)) {
+        String _xblockexpression_1 = null;
+        {
+          String res = "{";
+          int i = 0;
+          while ((i < size)) {
+            {
+              res = (res + dv);
+              i = (i + 1);
+              if ((i < size)) {
+                res = (res + ",");
+              }
+            }
+          }
+          _xblockexpression_1 = (res + "}");
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        _xifexpression = dv;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String[] generateArglistAndTypedData(final EObject d) {
+    if ((Objects.equal(d, null) || (!(d instanceof VarDecl)))) {
+      return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList("", "", ""), String.class));
+    }
+    final VarDecl data = ((VarDecl) d);
+    String _switchResult = null;
+    DataType _type = data.getRefType().getType();
+    final DataType it = _type;
+    boolean _matched = false;
+    if (it instanceof PrimitiveType) {
+      boolean _isEmpty = Strings.isEmpty(((PrimitiveType)it).getCastName());
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        _matched=true;
+        _switchResult = ((PrimitiveType)it).getCastName();
+      }
+    }
+    if (!_matched) {
+      if (it instanceof EnumerationType) {
+        _matched=true;
+        _switchResult = this.getCastType(((EnumerationType)it));
+      }
+    }
+    if (!_matched) {
+      _switchResult = this._typeHelpers.typeName(it);
+    }
+    final String castExpr = (_switchResult + "*");
+    String _typeName = this._typeHelpers.typeName(data.getRefType().getType());
+    String _switchResult_1 = null;
+    RefableType _refType = data.getRefType();
+    final RefableType it_1 = _refType;
+    boolean _matched_1 = false;
+    boolean _isRef = it_1.isRef();
+    if (_isRef) {
+      _matched_1=true;
+      _switchResult_1 = "*";
+    }
+    if (!_matched_1) {
+      boolean _isPrimitive = this._typeHelpers.isPrimitive(it_1.getType());
+      if (_isPrimitive) {
+        _matched_1=true;
+        _switchResult_1 = "";
+      }
+    }
+    if (!_matched_1) {
+      _switchResult_1 = "&";
+    }
+    final String typeExpr = (_typeName + _switchResult_1);
+    String _xifexpression = null;
+    boolean _isRef_1 = data.getRefType().isRef();
+    boolean _not = (!_isRef_1);
+    if (_not) {
+      _xifexpression = "*";
+    } else {
+      _xifexpression = "";
+    }
+    String deRef = _xifexpression;
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(", ");
+    _builder.append(ILanguageExtension.GENERIC_DATA_NAME);
+    final String dataArg = _builder.toString();
+    StringConcatenation _builder_1 = new StringConcatenation();
+    _builder_1.append(typeExpr);
+    _builder_1.append(" ");
+    _builder_1.append(ILanguageExtension.GENERIC_DATA_NAME);
+    _builder_1.append(" = ");
+    _builder_1.append(deRef);
+    _builder_1.append("(static_cast<");
+    _builder_1.append(castExpr);
+    _builder_1.append(">(generic_data__et));");
+    final String typedData = (_builder_1.toString() + this._roomExtensions.NEWLINE);
+    StringConcatenation _builder_2 = new StringConcatenation();
+    _builder_2.append(", ");
+    _builder_2.append(typeExpr);
+    _builder_2.append(" ");
+    _builder_2.append(ILanguageExtension.GENERIC_DATA_NAME);
+    final String typedArgList = _builder_2.toString();
+    return new String[] { dataArg, typedData, typedArgList };
+  }
+  
+  @Override
+  public String getTargetType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getTargetName();
+    } else {
+      _xifexpression = type.getName();
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String getCastedValue(final EnumLiteral literal) {
+    String _xblockexpression = null;
+    {
+      EObject _eContainer = literal.eContainer();
+      final EnumerationType type = ((EnumerationType) _eContainer);
+      final String cast = this.getTargetType(type);
+      String _xifexpression = null;
+      PrimitiveType _primitiveType = type.getPrimitiveType();
+      boolean _notEquals = (!Objects.equal(_primitiveType, null));
+      if (_notEquals) {
+        _xifexpression = Long.toString(literal.getLiteralValue());
+      } else {
+        String _string = Long.toString(literal.getLiteralValue());
+        String _plus = ((("((" + cast) + ")") + _string);
+        _xifexpression = (_plus + ")");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getCastType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getCastName();
+    } else {
+      _xifexpression = type.getName();
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String makeOverridable() {
+    return "virtual ";
+  }
+  
+  /**
+   * check if there is an ImplementationSubclass annotation and return its fully qualified name or the actor class name
+   */
+  public String getImplementationClassName(final ActorClass ac) {
+    String _xblockexpression = null;
+    {
+      final List<KeyValue> attributes = this._roomHelpers.getAttributes(ac, "ImplementationSubclass");
+      String _xifexpression = null;
+      boolean _isEmpty = attributes.isEmpty();
+      if (_isEmpty) {
+        _xifexpression = ac.getName();
+      } else {
+        final Function1<KeyValue, Boolean> _function = (KeyValue it) -> {
+          String _key = it.getKey();
+          return Boolean.valueOf(Objects.equal(_key, "fqnClassName"));
+        };
+        _xifexpression = this._roomHelpers.literalToString(IterableExtensions.<KeyValue>head(IterableExtensions.<KeyValue>filter(attributes, _function)).getValue());
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * check if there is an ImplementationSubclass annotation. If it also has an includePath use it.
+   * If there is not includePath, use the class name as base file name.
+   * If there is no annotation use the default path.
+   */
+  public String getActorIncludePath(final ActorClass ac) {
+    String _xblockexpression = null;
+    {
+      final List<KeyValue> attributes = this._roomHelpers.getAttributes(ac, "ImplementationSubclass");
+      String _xifexpression = null;
+      boolean _isEmpty = attributes.isEmpty();
+      if (_isEmpty) {
+        String _path = this._roomExtensions.getPath(ac);
+        String _name = ac.getName();
+        String _plus = (_path + _name);
+        _xifexpression = (_plus + ".h");
+      } else {
+        String _xblockexpression_1 = null;
+        {
+          final Function1<KeyValue, Boolean> _function = (KeyValue it) -> {
+            String _key = it.getKey();
+            return Boolean.valueOf(Objects.equal(_key, "includePath"));
+          };
+          final Iterable<KeyValue> path = IterableExtensions.<KeyValue>filter(attributes, _function);
+          String _xifexpression_1 = null;
+          boolean _isEmpty_1 = IterableExtensions.isEmpty(path);
+          if (_isEmpty_1) {
+            String _xblockexpression_2 = null;
+            {
+              final Function1<KeyValue, Boolean> _function_1 = (KeyValue it) -> {
+                String _key = it.getKey();
+                return Boolean.valueOf(Objects.equal(_key, "fqnClassName"));
+              };
+              final String baseName = IterableExtensions.<String>last(((Iterable<String>)Conversions.doWrapArray(this._roomHelpers.literalToString(IterableExtensions.<KeyValue>head(IterableExtensions.<KeyValue>filter(attributes, _function_1)).getValue()).split("::"))));
+              _xblockexpression_2 = (baseName + ".h");
+            }
+            _xifexpression_1 = _xblockexpression_2;
+          } else {
+            _xifexpression_1 = this._roomHelpers.literalToString(IterableExtensions.<KeyValue>head(path).getValue());
+          }
+          _xblockexpression_1 = _xifexpression_1;
+        }
+        _xifexpression = _xblockexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/DataClassGen.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/DataClassGen.java
new file mode 100644
index 000000000..eb5cf13b8
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/DataClassGen.java
@@ -0,0 +1,623 @@
+/**
+ * Copyright (c) 2011 Draeger Medical GmbH (http://www.draeger.com).
+ * 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:
+ * 		Peter Karlitschek (initial contribution)
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+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.DataType;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.cpp.gen.CppExtensions;
+import org.eclipse.etrice.generator.cpp.gen.CppProcedureHelpers;
+import org.eclipse.etrice.generator.cpp.gen.Initialization;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class DataClassGen {
+  @Inject
+  @Extension
+  private JavaIoFileSystemAccess fileAccess;
+  
+  @Inject
+  @Extension
+  private CppExtensions stdExt;
+  
+  @Inject
+  @Extension
+  private RoomExtensions roomExt;
+  
+  @Inject
+  @Extension
+  private CppProcedureHelpers helpers;
+  
+  @Inject
+  private Initialization initHelper;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    this.logger.logInfo("generating code");
+    EList<DataClass> _dataClasses = root.getDataClasses();
+    for (final DataClass dc : _dataClasses) {
+      {
+        String _generationTargetPath = this.roomExt.getGenerationTargetPath(dc);
+        String _path = this.roomExt.getPath(dc);
+        String path = (_generationTargetPath + _path);
+        String _cppHeaderFileName = this.stdExt.getCppHeaderFileName(dc);
+        String _plus = ("generating DataClass header \'" + _cppHeaderFileName);
+        String _plus_1 = (_plus + "\' in \'");
+        String _plus_2 = (_plus_1 + path);
+        String _plus_3 = (_plus_2 + "\'");
+        this.logger.logInfo(_plus_3);
+        this.fileAccess.setOutputPath(path);
+        this.fileAccess.generateFile(this.stdExt.getCppHeaderFileName(dc), this.generateHeaderFile(root, dc));
+        String _cppSourceFileName = this.stdExt.getCppSourceFileName(dc);
+        String _plus_4 = ("generating DataClass source \'" + _cppSourceFileName);
+        String _plus_5 = (_plus_4 + "\' in \'");
+        String _plus_6 = (_plus_5 + path);
+        String _plus_7 = (_plus_6 + "\'");
+        this.logger.logInfo(_plus_7);
+        this.fileAccess.setOutputPath(path);
+        this.fileAccess.generateFile(this.stdExt.getCppSourceFileName(dc), this.generateSourceFile(root, dc));
+      }
+    }
+  }
+  
+  public CharSequence generateHeaderFile(final Root root, final DataClass dc) {
+    StringConcatenation _builder = new StringConcatenation();
+    CharSequence _generateIncludeGuardBegin = this.stdExt.generateIncludeGuardBegin(dc, "");
+    _builder.append(_generateIncludeGuardBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"common/etDatatypesCpp.hpp\"");
+    _builder.newLine();
+    {
+      DataClass _base = dc.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        _builder.append("#include \"");
+        String _path = this.roomExt.getPath(dc.getBase());
+        _builder.append(_path);
+        String _name = dc.getBase().getName();
+        _builder.append(_name);
+        _builder.append(".h\"");
+      }
+    }
+    _builder.newLineIfNotEmpty();
+    {
+      EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(dc);
+      for(final DataClass classes : _referencedDataClasses) {
+        _builder.append("#include \"");
+        String _path_1 = this.roomExt.getPath(classes);
+        _builder.append(_path_1);
+        String _name_1 = classes.getName();
+        _builder.append(_name_1);
+        _builder.append(".h\"");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    {
+      EList<RoomModel> _referencedModels = root.getReferencedModels(dc);
+      for(final RoomModel model : _referencedModels) {
+        {
+          EList<DataClass> _dataClasses = model.getDataClasses();
+          for(final DataClass classes_1 : _dataClasses) {
+            _builder.append("#include \"");
+            String _path_2 = this.roomExt.getPath(classes_1);
+            _builder.append(_path_2);
+            String _name_2 = classes_1.getName();
+            _builder.append(_name_2);
+            _builder.append(".h\"");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    _builder.newLine();
+    CharSequence _userCode = this.helpers.userCode(dc.getUserCode1());
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("using namespace etRuntime; // TODO JH remove");
+    _builder.newLine();
+    _builder.newLine();
+    String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(dc);
+    _builder.append(_generateNamespaceBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("class ");
+    String _name_3 = dc.getName();
+    _builder.append(_name_3);
+    {
+      DataClass _base_1 = dc.getBase();
+      boolean _notEquals_1 = (!Objects.equal(_base_1, null));
+      if (_notEquals_1) {
+        _builder.append(" : public ");
+        String _name_4 = dc.getBase().getName();
+        _builder.append(_name_4);
+      }
+    }
+    _builder.append(" {");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("public:");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _userCode_1 = this.helpers.userCode(dc.getUserCode2());
+    _builder.append(_userCode_1, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _attributes = this.helpers.attributes(dc.getAttributes());
+    _builder.append(_attributes, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _attributeSettersGettersImplementation = this.helpers.attributeSettersGettersImplementation(dc.getAttributes(), dc.getName());
+    _builder.append(_attributeSettersGettersImplementation, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _operationsDeclaration = this.helpers.operationsDeclaration(dc.getOperations(), dc.getName());
+    _builder.append(_operationsDeclaration, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("// default constructor, copy constructor and assignment operator");
+    _builder.newLine();
+    _builder.append("\t");
+    String _name_5 = dc.getName();
+    _builder.append(_name_5, "\t");
+    _builder.append("();");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    String _name_6 = dc.getName();
+    _builder.append(_name_6, "\t");
+    _builder.append("(const ");
+    String _name_7 = dc.getName();
+    _builder.append(_name_7, "\t");
+    _builder.append("& rhs);");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("// constructor using fields");
+    _builder.newLine();
+    _builder.append("\t");
+    {
+      boolean _isEmpty = this._roomHelpers.getAllAttributes(dc).isEmpty();
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        String _name_8 = dc.getName();
+        _builder.append(_name_8, "\t");
+        _builder.append("(");
+        String _constArgList = this.helpers.constArgList(this._roomHelpers.getAllAttributes(dc));
+        _builder.append(_constArgList, "\t");
+        _builder.append(");");
+      }
+    }
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    String _name_9 = dc.getName();
+    _builder.append(_name_9, "\t");
+    _builder.append("& operator=(const ");
+    String _name_10 = dc.getName();
+    _builder.append(_name_10, "\t");
+    _builder.append("& rhs);");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("};");
+    _builder.newLine();
+    _builder.newLine();
+    String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(dc);
+    _builder.append(_generateNamespaceEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardEnd = this.stdExt.generateIncludeGuardEnd(dc, "");
+    _builder.append(_generateIncludeGuardEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    return _builder;
+  }
+  
+  public CharSequence generateSourceFile(final Root root, final DataClass dc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Source File of DataClass ");
+    String _name = dc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("#include \"");
+    String _cppHeaderFileName = this.stdExt.getCppHeaderFileName(dc);
+    _builder.append(_cppHeaderFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"etUnit/etUnit.h\"");
+    _builder.newLine();
+    _builder.newLine();
+    String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(dc);
+    _builder.append(_generateNamespaceBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _userCode = this.helpers.userCode(dc.getUserCode3());
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("// default constructor");
+    _builder.newLine();
+    String _name_1 = dc.getName();
+    _builder.append(_name_1);
+    _builder.append("::");
+    String _name_2 = dc.getName();
+    _builder.append(_name_2);
+    _builder.append("()");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    CharSequence _generateDefaultInitalizerList = this.generateDefaultInitalizerList(dc);
+    _builder.append(_generateDefaultInitalizerList, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("{");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _genExtraInitializers = this.initHelper.genExtraInitializers(dc.getAttributes());
+    _builder.append(_genExtraInitializers, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    String _userStructorBody = this.helpers.userStructorBody(dc, true);
+    _builder.append(_userStructorBody, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("// copy constructor");
+    _builder.newLine();
+    String _name_3 = dc.getName();
+    _builder.append(_name_3);
+    _builder.append("::");
+    String _name_4 = dc.getName();
+    _builder.append(_name_4);
+    _builder.append("(const ");
+    String _name_5 = dc.getName();
+    _builder.append(_name_5);
+    _builder.append("& rhs)");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    CharSequence _generateCopyInitalizerList = this.generateCopyInitalizerList(dc);
+    _builder.append(_generateCopyInitalizerList, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("{");
+    _builder.newLine();
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("// constructor using fields");
+    _builder.newLine();
+    _builder.append("// TODO");
+    _builder.newLine();
+    {
+      boolean _isEmpty = this._roomHelpers.getAllAttributes(dc).isEmpty();
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        String _name_6 = dc.getName();
+        _builder.append(_name_6);
+        _builder.append("::");
+        String _name_7 = dc.getName();
+        _builder.append(_name_7);
+        _builder.append("(");
+        String _constArgList = this.helpers.constArgList(this._roomHelpers.getAllAttributes(dc));
+        _builder.append(_constArgList);
+        _builder.append(")");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        CharSequence _generateFieldInitializerList = this.generateFieldInitializerList(dc);
+        _builder.append(_generateFieldInitializerList, "\t");
+        _builder.newLineIfNotEmpty();
+        _builder.append("{");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+      }
+    }
+    _builder.newLine();
+    _builder.append("// assignment operator");
+    _builder.newLine();
+    String _name_8 = dc.getName();
+    _builder.append(_name_8);
+    _builder.append("& ");
+    String _name_9 = dc.getName();
+    _builder.append(_name_9);
+    _builder.append("::operator=(const ");
+    String _name_10 = dc.getName();
+    _builder.append(_name_10);
+    _builder.append("& rhs)");
+    _builder.newLineIfNotEmpty();
+    _builder.append("{");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("if (this == &rhs) { return *this; };");
+    _builder.newLine();
+    _builder.append("\t");
+    {
+      DataClass _base = dc.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        String _name_11 = dc.getBase().getName();
+        _builder.append(_name_11, "\t");
+        _builder.append("::operator=(rhs);");
+      }
+    }
+    _builder.newLineIfNotEmpty();
+    {
+      EList<Attribute> _attributes = dc.getAttributes();
+      for(final Attribute attr : _attributes) {
+        _builder.append("\t");
+        _builder.append("this->");
+        String _name_12 = attr.getName();
+        _builder.append(_name_12, "\t");
+        _builder.append(" = rhs.");
+        String _name_13 = attr.getName();
+        _builder.append(_name_13, "\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.append("\t");
+    _builder.append("return *this;");
+    _builder.newLine();
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _operationsImplementation = this.helpers.operationsImplementation(dc.getOperations(), dc.getName());
+    _builder.append(_operationsImplementation);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(dc);
+    _builder.append(_generateNamespaceEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence generateDefaultInitalizerList(final DataClass dataClass) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      ArrayList<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      DataClass _base = dataClass.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        String _name = dataClass.getBase().getName();
+        String _plus = (_name + "()");
+        initList.add(_plus);
+      }
+      final Function1<Attribute, String> _function = (Attribute it) -> {
+        StringConcatenation _builder = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder.append(_name_1);
+        _builder.append("(");
+        String _initializerListValue = initHelper.getInitializerListValue(it);
+        _builder.append(_initializerListValue);
+        _builder.append(")");
+        return _builder.toString();
+      };
+      List<String> _map = ListExtensions.<Attribute, String>map(dataClass.getAttributes(), _function);
+      Iterables.<CharSequence>addAll(initList, _map);
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateCopyInitalizerList(final DataClass dataClass) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      ArrayList<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      DataClass _base = dataClass.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        String _name = dataClass.getBase().getName();
+        String _plus = (_name + "(rhs)");
+        initList.add(_plus);
+      }
+      final Function1<Attribute, String> _function = (Attribute it) -> {
+        StringConcatenation _builder = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder.append(_name_1);
+        _builder.append("(rhs.");
+        String _name_2 = it.getName();
+        _builder.append(_name_2);
+        _builder.append(")");
+        return _builder.toString();
+      };
+      List<String> _map = ListExtensions.<Attribute, String>map(dataClass.getAttributes(), _function);
+      Iterables.<CharSequence>addAll(initList, _map);
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateFieldInitializerList(final DataClass dataClass) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      ArrayList<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      DataClass _base = dataClass.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        StringConcatenation _builder = new StringConcatenation();
+        String _name = dataClass.getBase().getName();
+        _builder.append(_name);
+        _builder.append("(");
+        final Function1<Attribute, String> _function = (Attribute it) -> {
+          return it.getName();
+        };
+        String _join = IterableExtensions.join(ListExtensions.<Attribute, String>map(this._roomHelpers.getAllAttributes(dataClass.getBase()), _function), ", ");
+        _builder.append(_join);
+        _builder.append(")");
+        initList.add(_builder.toString());
+      }
+      final Function1<Attribute, String> _function_1 = (Attribute it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("(");
+        String _name_2 = it.getName();
+        _builder_1.append(_name_2);
+        _builder_1.append(")");
+        return _builder_1.toString();
+      };
+      List<String> _map = ListExtensions.<Attribute, String>map(dataClass.getAttributes(), _function_1);
+      Iterables.<CharSequence>addAll(initList, _map);
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  public String deepCopy(final DataClass _dc) {
+    String result = "";
+    DataClass dc = _dc;
+    while ((!Objects.equal(dc, null))) {
+      {
+        String _string = this.deepCopy(dc.getAttributes()).toString();
+        String _plus = (_string + result);
+        result = _plus;
+        dc = dc.getBase();
+      }
+    }
+    return result;
+  }
+  
+  public CharSequence deepCopy(final List<Attribute> attributes) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      for(final Attribute a : attributes) {
+        {
+          DataType _type = a.getType().getType();
+          if ((_type instanceof ComplexType)) {
+            _builder.append("if (");
+            String _name = a.getName();
+            _builder.append(_name);
+            _builder.append("!=null) {");
+            _builder.newLineIfNotEmpty();
+            {
+              int _size = a.getSize();
+              boolean _equals = (_size == 0);
+              if (_equals) {
+                _builder.append("\t");
+                _builder.append("copy.");
+                String _name_1 = a.getName();
+                _builder.append(_name_1, "\t");
+                _builder.append(" = ");
+                String _name_2 = a.getName();
+                _builder.append(_name_2, "\t");
+                _builder.append(".deepCopy();");
+                _builder.newLineIfNotEmpty();
+              } else {
+                _builder.append("\t");
+                _builder.append("for (int i=0;i<");
+                String _name_3 = a.getName();
+                _builder.append(_name_3, "\t");
+                _builder.append(".length;i++){");
+                _builder.newLineIfNotEmpty();
+                _builder.append("\t");
+                _builder.append("\t");
+                _builder.append("copy.");
+                String _name_4 = a.getName();
+                _builder.append(_name_4, "\t\t");
+                _builder.append("[i] = ");
+                String _name_5 = a.getName();
+                _builder.append(_name_5, "\t\t");
+                _builder.append("[i].deepCopy();");
+                _builder.newLineIfNotEmpty();
+                _builder.append("\t");
+                _builder.append("}");
+                _builder.newLine();
+              }
+            }
+            _builder.append("}");
+            _builder.newLine();
+          } else {
+            {
+              int _size_1 = a.getSize();
+              boolean _equals_1 = (_size_1 == 0);
+              if (_equals_1) {
+                _builder.append("copy.");
+                String _name_6 = a.getName();
+                _builder.append(_name_6);
+                _builder.append(" = ");
+                String _name_7 = a.getName();
+                _builder.append(_name_7);
+                _builder.append(";");
+                _builder.newLineIfNotEmpty();
+              } else {
+                _builder.append("for (int i=0;i<");
+                String _name_8 = a.getName();
+                _builder.append(_name_8);
+                _builder.append(".length;i++){");
+                _builder.newLineIfNotEmpty();
+                _builder.append("\t");
+                _builder.append("copy.");
+                String _name_9 = a.getName();
+                _builder.append(_name_9, "\t");
+                _builder.append("[i] = ");
+                String _name_10 = a.getName();
+                _builder.append(_name_10, "\t");
+                _builder.append("[i];");
+                _builder.newLineIfNotEmpty();
+                _builder.append("}");
+                _builder.newLine();
+              }
+            }
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/NodeGen.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/NodeGen.java
new file mode 100644
index 000000000..8f75401a9
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/NodeGen.java
@@ -0,0 +1,854 @@
+/**
+ * Copyright (c) 2011 Draeger Medical GmbH (http://www.draeger.com).
+ * 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:
+ * 		Peter Karlitschek (initial contribution)
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.common.converter.TimeConverter;
+import org.eclipse.etrice.core.etmap.util.ETMapUtil;
+import org.eclipse.etrice.core.etphys.eTPhys.ExecMode;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.etphys.eTPhys.PhysicalThread;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+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.Wire;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredSubSystemClass;
+import org.eclipse.etrice.core.room.ActorRef;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SubSystemClass;
+import org.eclipse.etrice.generator.cpp.Main;
+import org.eclipse.etrice.generator.cpp.gen.CppExtensions;
+import org.eclipse.etrice.generator.cpp.gen.Initialization;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.fsm.base.Indexed;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class NodeGen {
+  @Inject
+  @Extension
+  private CppExtensions _cppExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  private Initialization initHelper;
+  
+  public void doGenerate(final Root root) {
+    final Map<SubSystemClass, WiredSubSystemClass> sscc2wired = CollectionLiterals.<SubSystemClass, WiredSubSystemClass>newHashMap();
+    final Consumer<WiredSubSystemClass> _function = (WiredSubSystemClass it) -> {
+      sscc2wired.put(it.getSubSystemClass(), it);
+    };
+    Iterables.<WiredSubSystemClass>filter(root.getWiredInstances(), WiredSubSystemClass.class).forEach(_function);
+    Collection<NodeRef> _nodeRefs = ETMapUtil.getNodeRefs();
+    for (final NodeRef nr : _nodeRefs) {
+      List<String> _subSystemInstancePaths = ETMapUtil.getSubSystemInstancePaths(nr);
+      for (final String instpath : _subSystemInstancePaths) {
+        {
+          StructureInstance _instance = root.getInstance(instpath);
+          final SubSystemInstance ssi = ((SubSystemInstance) _instance);
+          if (((!Objects.equal(ssi, null)) && this._fileSystemHelpers.isValidGenerationLocation(ssi.getSubSystemClass()))) {
+            final WiredSubSystemClass wired = sscc2wired.get(ssi.getSubSystemClass());
+            String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(ssi.getSubSystemClass());
+            String _path = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String path = (_generationTargetPath + _path);
+            String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(ssi.getSubSystemClass());
+            String _path_1 = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String infopath = (_generationInfoPath + _path_1);
+            final Set<PhysicalThread> usedThreads = ETMapUtil.getUsedThreads(nr, ssi);
+            this.fileIO.generateFile("generating Node declaration", path, infopath, this._cppExtensions.getCppHeaderFileName(nr, ssi), this.generateHeaderFile(root, ssi, wired, usedThreads));
+            this.fileIO.generateFile("generating Node implementation", path, infopath, this._cppExtensions.getCppSourceFileName(nr, ssi), this.generateSourceFile(root, ssi, wired, usedThreads));
+          }
+        }
+      }
+    }
+  }
+  
+  public CharSequence generateHeaderFile(final Root root, final SubSystemInstance comp, final WiredSubSystemClass wired, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final SubSystemClass cc = comp.getSubSystemClass();
+      final EList<RoomModel> models = root.getReferencedModels(cc);
+      final NodeRef nr = ETMapUtil.getNodeRef(comp);
+      final String clsname = this._cppExtensions.getCppClassName(nr, comp);
+      final Function1<PhysicalThread, Boolean> _function = (PhysicalThread t) -> {
+        return Boolean.valueOf(usedThreads.contains(t));
+      };
+      final Iterable<PhysicalThread> threads = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Header File of SubSystemClass ");
+      _builder.append(clsname, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this._cppExtensions.generateIncludeGuardBegin(cc, "");
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/IMessageService.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/SubSystemClassBase.h\"");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _actorInstances = comp.getActorInstances();
+        for(final ActorInstance ai : _actorInstances) {
+          _builder.append("#include \"");
+          String _actorIncludePath = this._cppExtensions.getActorIncludePath(ai.getActorClass());
+          _builder.append(_actorIncludePath);
+          _builder.append("\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(cc.getUserCode1());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      String _generateNamespaceBegin = this._cppExtensions.generateNamespaceBegin(cc);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("class ");
+      _builder.append(clsname);
+      _builder.append(" : public etRuntime::SubSystemClassBase{");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(cc.getUserCode2());
+      _builder.append(_userCode_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public:");
+      _builder.newLine();
+      {
+        Iterable<Indexed<PhysicalThread>> _indexed = Indexed.<PhysicalThread>indexed(threads);
+        for(final Indexed<PhysicalThread> thread : _indexed) {
+          _builder.append("\t\t");
+          _builder.append("static const int ");
+          String _threadId = this.getThreadId(thread.getValue());
+          _builder.append(_threadId, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t\t");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs = cc.getActorRefs();
+        for(final ActorRef sub : _actorRefs) {
+          {
+            int _multiplicity = sub.getMultiplicity();
+            boolean _greaterThan = (_multiplicity > 1);
+            if (_greaterThan) {
+              _builder.append("\t\t");
+              _builder.append("Replicated");
+              String _implementationClassName = this._cppExtensions.getImplementationClassName(sub.getType());
+              _builder.append(_implementationClassName, "\t\t");
+              _builder.append(" ");
+              String _name = sub.getName();
+              _builder.append(_name, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t\t");
+              String _implementationClassName_1 = this._cppExtensions.getImplementationClassName(sub.getType());
+              _builder.append(_implementationClassName_1, "\t\t");
+              _builder.append(" ");
+              String _name_1 = sub.getName();
+              _builder.append(_name_1, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append(clsname, "\t\t");
+      _builder.append("(IRTObject* parent, const String& name);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("~");
+      _builder.append(clsname, "\t\t");
+      _builder.append("();");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void receiveEvent(etRuntime::InterfaceItemBase* ifitem, int evt, void* data);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void instantiateMessageServices();");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void mapThreads(void);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void initialize(void);");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t\t");
+          _builder.append("virtual void setProbesActive(bool recursive, bool active);");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual void init();");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.append("\t\t");
+          _builder.append("etBool hasGeneratedMSCInstrumentation() const { return true; }");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("virtual void destroy();");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("private:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// MessageServices");
+      _builder.newLine();
+      {
+        for(final PhysicalThread thread_1 : threads) {
+          _builder.append("\t\t");
+          _builder.append("IMessageService* msgSvc_");
+          String _name_2 = thread_1.getName();
+          _builder.append(_name_2, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append(clsname, "\t\t");
+      _builder.append("();");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append(clsname, "\t\t");
+      _builder.append("(");
+      _builder.append(clsname, "\t\t");
+      _builder.append(" const&);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append(clsname, "\t\t");
+      _builder.append("& operator=(");
+      _builder.append(clsname, "\t\t");
+      _builder.append(" const&);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceEnd = this._cppExtensions.generateNamespaceEnd(cc);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this._cppExtensions.generateIncludeGuardEnd(cc, "");
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getThreadId(final PhysicalThread thread) {
+    String _upperCase = thread.getName().toUpperCase();
+    return ("THREAD_" + _upperCase);
+  }
+  
+  private CharSequence generateConstructorInitalizerList(final SubSystemClass cc) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      ArrayList<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("SubSystemClassBase(parent, name)");
+      initList.add(_builder.toString());
+      final Function1<ActorRef, String> _function = (ActorRef it) -> {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _name = it.getName();
+        _builder_1.append(_name);
+        _builder_1.append("(this, \"");
+        String _name_1 = it.getName();
+        _builder_1.append(_name_1);
+        _builder_1.append("\")");
+        return _builder_1.toString();
+      };
+      List<String> _map = ListExtensions.<ActorRef, String>map(cc.getActorRefs(), _function);
+      Iterables.<CharSequence>addAll(initList, _map);
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence generateSourceFile(final Root root, final SubSystemInstance comp, final WiredSubSystemClass wired, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final SubSystemClass cc = comp.getSubSystemClass();
+      final EList<RoomModel> models = root.getReferencedModels(cc);
+      final NodeRef nr = ETMapUtil.getNodeRef(comp);
+      final String clsname = this._cppExtensions.getCppClassName(nr, comp);
+      final Function1<PhysicalThread, Boolean> _function = (PhysicalThread t) -> {
+        return Boolean.valueOf(usedThreads.contains(t));
+      };
+      final Iterable<PhysicalThread> threads = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Source File of SubsystemClass ");
+      _builder.append(clsname, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cppHeaderFileName = this._cppExtensions.getCppHeaderFileName(nr, comp);
+      _builder.append(_cppHeaderFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"common/debugging/DebuggingService.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/debugging/MSCFunctionObject.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/IMessageService.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/MessageService.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/MessageServiceController.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/RTServices.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/messaging/StaticMessageMemory.h\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/InterfaceItemBase.h\"");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("using namespace etRuntime;");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceBegin = this._cppExtensions.generateNamespaceBegin(cc);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        Iterable<Indexed<PhysicalThread>> _indexed = Indexed.<PhysicalThread>indexed(threads);
+        for(final Indexed<PhysicalThread> thread : _indexed) {
+          _builder.append("const int ");
+          _builder.append(clsname);
+          _builder.append("::");
+          String _threadId = this.getThreadId(thread.getValue());
+          _builder.append(_threadId);
+          _builder.append(" = ");
+          int _index0 = thread.getIndex0();
+          _builder.append(_index0);
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append(clsname);
+      _builder.append("::");
+      _builder.append(clsname);
+      _builder.append("(IRTObject* parent, const String& name)");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      CharSequence _generateConstructorInitalizerList = this.generateConstructorInitalizerList(cc);
+      _builder.append(_generateConstructorInitalizerList, "\t\t");
+      _builder.newLineIfNotEmpty();
+      {
+        for(final PhysicalThread thread_1 : threads) {
+          _builder.append("\t\t");
+          _builder.append(", msgSvc_");
+          String _name = thread_1.getName();
+          _builder.append(_name, "\t\t");
+          _builder.append("(NULL)");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("{");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"Constructor\");");
+          _builder.newLine();
+        }
+      }
+      {
+        EList<ActorRef> _actorRefs = cc.getActorRefs();
+        for(final ActorRef sub : _actorRefs) {
+          {
+            int _multiplicity = sub.getMultiplicity();
+            boolean _greaterThan = (_multiplicity > 1);
+            if (_greaterThan) {
+              _builder.append("\t");
+              String _name_1 = sub.getName();
+              _builder.append(_name_1, "\t");
+              _builder.append(".createSubActors(");
+              int _multiplicity_1 = sub.getMultiplicity();
+              _builder.append(_multiplicity_1, "\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append(clsname);
+      _builder.append("::~");
+      _builder.append(clsname);
+      _builder.append("() {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"Destructor\");");
+          _builder.newLine();
+        }
+      }
+      {
+        for(final PhysicalThread thread_2 : threads) {
+          _builder.append("\t");
+          _builder.append("delete msgSvc_");
+          String _name_2 = thread_2.getName();
+          _builder.append(_name_2, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("::receiveEvent(InterfaceItemBase* ifitem, int evt, void* data){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("::instantiateMessageServices(){");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_2) {
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"instantiateMessageServices()\");");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("IMessageMemory* msgMemory;");
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Long> _function_1 = (PhysicalThread it) -> {
+          long _prio = it.getPrio();
+          return Long.valueOf((-_prio));
+        };
+        List<PhysicalThread> _sortBy = IterableExtensions.<PhysicalThread, Long>sortBy(threads, _function_1);
+        for(final PhysicalThread thread_3 : _sortBy) {
+          _builder.append("\t");
+          _builder.append("{");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("msgMemory = new StaticMessageMemory(this, \"MessageMemory_");
+          String _name_3 = thread_3.getName();
+          _builder.append(_name_3, "\t\t");
+          _builder.append("\", ");
+          int _msgblocksize = thread_3.getMsgblocksize();
+          _builder.append(_msgblocksize, "\t\t");
+          _builder.append(", ");
+          int _msgpoolsize = thread_3.getMsgpoolsize();
+          _builder.append(_msgpoolsize, "\t\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          {
+            if ((Objects.equal(thread_3.getExecmode(), ExecMode.POLLED) || Objects.equal(thread_3.getExecmode(), ExecMode.MIXED))) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("etTime interval;");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("interval.sec = ");
+              long _split = TimeConverter.split(thread_3.getTime(), TimeConverter.SEC, true);
+              _builder.append(_split, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("interval.nSec = ");
+              long _split_1 = TimeConverter.split(thread_3.getTime(), TimeConverter.MILLI_SEC, false);
+              _builder.append(_split_1, "\t\t");
+              _builder.append("L;");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("msgSvc_");
+              String _name_4 = thread_3.getName();
+              _builder.append(_name_4, "\t\t");
+              _builder.append(" = new MessageService(this, IMessageService::");
+              String _name_5 = thread_3.getExecmode().getName();
+              _builder.append(_name_5, "\t\t");
+              _builder.append(", interval, 0, ");
+              String _threadId_1 = this.getThreadId(thread_3);
+              _builder.append(_threadId_1, "\t\t");
+              _builder.append(", \"MessageService_");
+              String _name_6 = thread_3.getName();
+              _builder.append(_name_6, "\t\t");
+              _builder.append("\", msgMemory, ");
+              long _prio = thread_3.getPrio();
+              _builder.append(_prio, "\t\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("msgSvc_");
+              String _name_7 = thread_3.getName();
+              _builder.append(_name_7, "\t\t");
+              _builder.append(" = new MessageService(this, IMessageService::");
+              String _name_8 = thread_3.getExecmode().getName();
+              _builder.append(_name_8, "\t\t");
+              _builder.append(", 0, ");
+              String _threadId_2 = this.getThreadId(thread_3);
+              _builder.append(_threadId_2, "\t\t");
+              _builder.append(", \"MessageService_");
+              String _name_9 = thread_3.getName();
+              _builder.append(_name_9, "\t\t");
+              _builder.append("\", msgMemory, ");
+              long _prio_1 = thread_3.getPrio();
+              _builder.append(_prio_1, "\t\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("RTServices::getInstance().getMsgSvcCtrl().addMsgSvc(*msgSvc_");
+          String _name_10 = thread_3.getName();
+          _builder.append(_name_10, "\t\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("::mapThreads() {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("// thread mappings");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances = comp.getAllContainedInstances();
+        for(final ActorInstance ai : _allContainedInstances) {
+          _builder.append("\t");
+          final ETMapUtil.MappedThread mapped = ETMapUtil.getMappedThread(ai);
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _not = (!(mapped.isImplicit() || mapped.isAsParent()));
+            if (_not) {
+              _builder.append("\t");
+              _builder.append("addPathToThread(\"");
+              String _path = ai.getPath();
+              _builder.append(_path, "\t");
+              _builder.append("\", ");
+              String _threadId_3 = this.getThreadId(mapped.getThread());
+              _builder.append(_threadId_3, "\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("::initialize() {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation_3 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_3) {
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().getSyncLogger().addVisibleComment(\"starting initialization\");");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"initialize()\");");
+          _builder.newLine();
+          {
+            EList<ActorRef> _actorRefs_1 = cc.getActorRefs();
+            for(final ActorRef sub_1 : _actorRefs_1) {
+              {
+                int _multiplicity_2 = sub_1.getMultiplicity();
+                boolean _greaterThan_1 = (_multiplicity_2 > 1);
+                if (_greaterThan_1) {
+                  _builder.append("\t");
+                  _builder.append("for (int i=0; i<");
+                  int _multiplicity_3 = sub_1.getMultiplicity();
+                  _builder.append(_multiplicity_3, "\t");
+                  _builder.append("; ++i) {");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("DebuggingService::getInstance().addMessageActorCreate(*this, ");
+                  String _name_11 = sub_1.getName();
+                  _builder.append(_name_11, "\t\t");
+                  _builder.append(".getSubActor(i)->getName());");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("}");
+                  _builder.newLine();
+                } else {
+                  _builder.append("\t");
+                  _builder.append("DebuggingService::getInstance().addMessageActorCreate(*this, \"");
+                  String _name_12 = sub_1.getName();
+                  _builder.append(_name_12, "\t");
+                  _builder.append("\");");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// wiring");
+      _builder.newLine();
+      {
+        EList<Wire> _wires = wired.getWires();
+        for(final Wire wire : _wires) {
+          _builder.append("\t");
+          String _xifexpression = null;
+          boolean _isDataDriven = wire.isDataDriven();
+          if (_isDataDriven) {
+            _xifexpression = "DataPortBase";
+          } else {
+            _xifexpression = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression, "\t");
+          _builder.append("::connect(this, \"");
+          String _join = IterableExtensions.join(wire.getPath1(), "/");
+          _builder.append(_join, "\t");
+          _builder.append("\", \"");
+          String _join_1 = IterableExtensions.join(wire.getPath2(), "/");
+          _builder.append(_join_1, "\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// call initialize of sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs_2 = cc.getActorRefs();
+        for(final ActorRef sub_2 : _actorRefs_2) {
+          _builder.append("\t");
+          String _name_13 = sub_2.getName();
+          _builder.append(_name_13, "\t");
+          _builder.append(".initialize();");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_4 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_4) {
+          _builder.append("void ");
+          _builder.append(clsname);
+          _builder.append("::setProbesActive(bool recursive, bool active) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("for(int i = 0; i < m_RTSystemPort.getNInterfaceItems(); i++)");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("DebuggingService::getInstance().addPortInstance(*(m_RTSystemPort.getInterfaceItem(i)));");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("if(recursive) {");
+          _builder.newLine();
+          {
+            EList<ActorRef> _actorRefs_3 = cc.getActorRefs();
+            for(final ActorRef sub_3 : _actorRefs_3) {
+              _builder.append("\t\t");
+              String _name_14 = sub_3.getName();
+              _builder.append(_name_14, "\t\t");
+              _builder.append(".setProbesActive(recursive, active);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(clsname);
+      _builder.append("::init(){");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("SubSystemClassBase::init();");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_5 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_5) {
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().addVisibleComment(\"done sub system initialization\");");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_6 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_6) {
+          _builder.newLine();
+          _builder.append("void ");
+          _builder.append(clsname);
+          _builder.append("::destroy() {");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _isGenerateMSCInstrumentation_7 = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation_7) {
+              _builder.append("\t");
+              _builder.append("DebuggingService::getInstance().getSyncLogger().addVisibleComment(\"starting destruction\");");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("MSCFunctionObject mscFunctionObject(getInstancePathName(), \"destroy()\");");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("DebuggingService::getInstance().addVisibleComment(\"begin sub system destruction\");");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("SubSystemClassBase::destroy();");
+          _builder.newLine();
+          {
+            boolean _isGenerateMSCInstrumentation_8 = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation_8) {
+              _builder.append("\t");
+              _builder.append("DebuggingService::getInstance().addVisibleComment(\"done sub system destruction\");");
+              _builder.newLine();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      String _generateNamespaceEnd = this._cppExtensions.generateNamespaceEnd(cc);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.java
new file mode 100644
index 000000000..6fef1fe28
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/ProtocolClassGen.java
@@ -0,0 +1,1543 @@
+/**
+ * Copyright (c) 2011 Draeger Medical GmbH (http://www.draeger.com).
+ * 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:
+ * 		Peter Karlitschek (initial contribution)
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.CommunicationType;
+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.MessageHandler;
+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.SAP;
+import org.eclipse.etrice.core.room.SPP;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.cpp.Main;
+import org.eclipse.etrice.generator.cpp.gen.CppExtensions;
+import org.eclipse.etrice.generator.cpp.gen.Initialization;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+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.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ProtocolClassGen extends GenericProtocolClassGenerator {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private CppExtensions stdExt;
+  
+  @Inject
+  @Extension
+  private RoomExtensions roomExt;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers helpers;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  private Initialization initHelper;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    final Function1<ProtocolClass, Boolean> _function = (ProtocolClass cl) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(cl));
+    };
+    Iterable<ProtocolClass> _filter = IterableExtensions.<ProtocolClass>filter(root.getProtocolClasses(), _function);
+    for (final ProtocolClass pc : _filter) {
+      {
+        String _generationTargetPath = this.roomExt.getGenerationTargetPath(pc);
+        String _path = this.roomExt.getPath(pc);
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this.roomExt.getGenerationInfoPath(pc);
+        String _path_1 = this.roomExt.getPath(pc);
+        final String infopath = (_generationInfoPath + _path_1);
+        CommunicationType _commType = pc.getCommType();
+        if (_commType != null) {
+          switch (_commType) {
+            case EVENT_DRIVEN:
+              this.fileIO.generateFile("generating ProtocolClass declaration", path, infopath, this.stdExt.getCppHeaderFileName(pc), this.generateHeaderFile(root, pc));
+              this.fileIO.generateFile("generating ProtocolClass implementation", path, infopath, this.stdExt.getCppSourceFileName(pc), this.generateSourceFile(root, pc));
+              break;
+            case DATA_DRIVEN:
+              this.fileIO.generateFile("generating ProtocolClass declaration", path, infopath, this.stdExt.getCppHeaderFileName(pc), this.generateDataDrivenHeaderFile(root, pc));
+              this.fileIO.generateFile("generating ProtocolClass implementation", path, infopath, this.stdExt.getCppSourceFileName(pc), this.generateDataDrivenSourceFile(root, pc));
+              break;
+            case SYNCHRONOUS:
+              this.logger.logError("synchronous protocols not supported yet", pc);
+              break;
+            default:
+              break;
+          }
+        }
+      }
+    }
+  }
+  
+  protected CharSequence generateHeaderFile(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Header File of ProtocolClass ");
+    String _name = pc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardBegin = this.stdExt.generateIncludeGuardBegin(pc, "");
+    _builder.append(_generateIncludeGuardBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"common/modelbase/InterfaceItemBase.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/modelbase/PortBase.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/modelbase/ReplicatedInterfaceItemBase.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/modelbase/ReplicatedPortBase.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/etDatatypesCpp.hpp\"");
+    _builder.newLine();
+    _builder.newLine();
+    {
+      EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(pc);
+      for(final DataClass dataClass : _referencedDataClasses) {
+        _builder.append("#include \"");
+        String _path = this.roomExt.getPath(dataClass);
+        _builder.append(_path);
+        String _name_1 = dataClass.getName();
+        _builder.append(_name_1);
+        _builder.append(".h\"");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.newLine();
+    CharSequence _userCode = this.helpers.userCode(pc.getUserCode1());
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(pc);
+    _builder.append(_generateNamespaceBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("class ");
+    String _name_2 = pc.getName();
+    _builder.append(_name_2);
+    _builder.append(" {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("   ");
+    _builder.append("public:");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("/* message IDs */");
+    _builder.newLine();
+    _builder.append("\t\t");
+    String _genMessageIDs = this.genMessageIDs(pc);
+    _builder.append(_genMessageIDs, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t\t");
+    CharSequence _userCode_1 = this.helpers.userCode(pc, 2);
+    _builder.append(_userCode_1, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static bool isValidEvtID(int evtId) {");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("return ((MSG_MIN < evtId) && (evtId < MSG_MAX));");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static bool isValidOutgoingEvtID(int evtId) {");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("return ((MSG_MIN < evtId) && (evtId < ");
+    {
+      int _size = pc.getIncomingMessages().size();
+      boolean _equals = (_size == 0);
+      if (_equals) {
+        _builder.append("MSG_MAX");
+      } else {
+        _builder.append("IN_");
+        String _name_3 = pc.getIncomingMessages().get(0).getName();
+        _builder.append(_name_3, "\t\t\t");
+      }
+    }
+    _builder.append("));");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static bool isValidIncomingEvtID(int evtId) {");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("return ((");
+    {
+      int _size_1 = pc.getIncomingMessages().size();
+      boolean _equals_1 = (_size_1 == 0);
+      if (_equals_1) {
+        _builder.append("MSG_MAX");
+      } else {
+        _builder.append("IN_");
+        String _name_4 = pc.getIncomingMessages().get(0).getName();
+        _builder.append(_name_4, "\t\t\t");
+      }
+    }
+    _builder.append(" <= evtId) && (evtId < MSG_MAX));");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static const etRuntime::String& getMessageString(int msg_id);");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("private:");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static const etRuntime::String s_messageStrings[];");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("};");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _portClassDeclaration = this.portClassDeclaration(pc, false);
+    _builder.append(_portClassDeclaration);
+    _builder.newLineIfNotEmpty();
+    CharSequence _portClassDeclaration_1 = this.portClassDeclaration(pc, true);
+    _builder.append(_portClassDeclaration_1);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(pc);
+    _builder.append(_generateNamespaceEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _generateIncludeGuardEnd = this.stdExt.generateIncludeGuardEnd(pc, "");
+    _builder.append(_generateIncludeGuardEnd);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  protected CharSequence portClassDeclaration(final ProtocolClass pc, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      PortClass pclass = this.roomExt.getPortClass(pc, conj);
+      String portClassName = this.roomExt.getPortClassName(pc, conj);
+      String replPortClassName = this.roomExt.getPortClassName(pc, conj, true);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("// ");
+      {
+        if (conj) {
+          _builder.append("conjugated ");
+        }
+      }
+      _builder.append("port class");
+      _builder.newLineIfNotEmpty();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("class ");
+      _builder.append(portClassName);
+      _builder.append(" : public etRuntime::PortBase {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _notEquals = (!Objects.equal(pclass, null));
+        if (_notEquals) {
+          _builder.append("\t");
+          CharSequence _userCode = this.helpers.userCode(pclass.getUserCode());
+          _builder.append(_userCode, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("   ");
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t ");
+      _builder.append(portClassName, "\t ");
+      _builder.append("(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t ");
+      _builder.append(portClassName, "\t ");
+      _builder.append("(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId, int idx);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t");
+          _builder.append("virtual void destroy();");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t ");
+      _builder.append("virtual void receive(const etRuntime::Message* m);");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _notEquals_1 = (!Objects.equal(pclass, null));
+        if (_notEquals_1) {
+          _builder.append("\t");
+          CharSequence _attributes = this.helpers.attributes(pclass.getAttributes());
+          _builder.append(_attributes, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _operationsDeclaration = this.helpers.operationsDeclaration(pclass.getOperations(), portClassName);
+          _builder.append(_operationsDeclaration, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t ");
+      _builder.append("// sent messages");
+      _builder.newLine();
+      {
+        List<Message> _allMessages = this._roomHelpers.getAllMessages(pc, conj);
+        for(final Message m : _allMessages) {
+          _builder.append("\t");
+          CharSequence _messageSignature = this.messageSignature(m, false);
+          _builder.append(_messageSignature, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _messageSignature_1 = this.messageSignature(m, true);
+          _builder.append(_messageSignature_1, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("// ");
+      {
+        if (conj) {
+          _builder.append("conjugated ");
+        }
+      }
+      _builder.append("replicated port class");
+      _builder.newLineIfNotEmpty();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("class ");
+      _builder.append(replPortClassName);
+      _builder.append(" : public etRuntime::ReplicatedPortBase {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append(replPortClassName, "\t\t");
+      _builder.append("(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("int getReplication() const { return getNInterfaceItems(); }");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("int getIndexOf(const etRuntime::InterfaceItemBase& ifitem) const { return ifitem.getIdx(); }");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append(portClassName, "\t\t");
+      _builder.append("& get(int idx) const { return *dynamic_cast<");
+      _builder.append(portClassName, "\t\t");
+      _builder.append("*>(getInterfaceItem(idx)); }");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if (conj) {
+          _builder.append("\t\t");
+          _builder.append("// incoming messages");
+          _builder.newLine();
+          {
+            List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+            for(final Message m_1 : _allIncomingMessages) {
+              _builder.append("\t\t");
+              CharSequence _messageSignature_2 = this.messageSignature(m_1, false);
+              _builder.append(_messageSignature_2, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        } else {
+          _builder.append("\t\t");
+          _builder.append("// outgoing messages");
+          _builder.newLine();
+          {
+            List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+            for(final Message m_2 : _allOutgoingMessages) {
+              _builder.append("\t\t");
+              CharSequence _messageSignature_3 = this.messageSignature(m_2, false);
+              _builder.append(_messageSignature_3, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("virtual etRuntime::InterfaceItemBase* createInterfaceItem(etRuntime::IInterfaceItemOwner* rcv, const etRuntime::String& name, int lid, int idx) {");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("return new ");
+      _builder.append(portClassName, "\t\t\t");
+      _builder.append("(rcv, name, lid, idx);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence generateSourceFile(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/**");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* @author generated by eTrice");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("* Source File of ProtocolClass ");
+    String _name = pc.getName();
+    _builder.append(_name, " ");
+    _builder.newLineIfNotEmpty();
+    _builder.append(" ");
+    _builder.append("*");
+    _builder.newLine();
+    _builder.append(" ");
+    _builder.append("*/");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("#include \"");
+    String _cppHeaderFileName = this.stdExt.getCppHeaderFileName(pc);
+    _builder.append(_cppHeaderFileName);
+    _builder.append("\"");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("#include \"common/debugging/DebuggingService.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/debugging/MSCFunctionObject.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/messaging/AbstractMessageReceiver.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/messaging/Address.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/messaging/Message.h\"");
+    _builder.newLine();
+    _builder.append("#include \"common/modelbase/IEventReceiver.h\"");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("using namespace etRuntime;");
+    _builder.newLine();
+    _builder.newLine();
+    String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(pc);
+    _builder.append(_generateNamespaceBegin);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _userCode = this.helpers.userCode(pc, 3);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* message names as strings for debugging (generate MSC) */");
+    _builder.newLine();
+    _builder.append("const String ");
+    String _name_1 = pc.getName();
+    _builder.append(_name_1);
+    _builder.append("::s_messageStrings[] = {\"MIN\", ");
+    {
+      List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+      for(final Message m : _allOutgoingMessages) {
+        _builder.append("\"");
+        String _name_2 = m.getName();
+        _builder.append(_name_2);
+        _builder.append("\",");
+      }
+    }
+    _builder.append(" ");
+    {
+      List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+      for(final Message m_1 : _allIncomingMessages) {
+        _builder.append("\"");
+        String _name_3 = m_1.getName();
+        _builder.append(_name_3);
+        _builder.append("\",");
+      }
+    }
+    _builder.append("\"MAX\"};");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("const String& ");
+    String _name_4 = pc.getName();
+    _builder.append(_name_4);
+    _builder.append("::getMessageString(int msg_id) {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("if ((MSG_MIN < msg_id ) && ( msg_id < MSG_MAX )) {");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("return s_messageStrings[msg_id];");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("} else {");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("// id out of range");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("static const String errorMsg = \"Message ID out of range\";");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("return errorMsg;");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _portClassImplementation = this.portClassImplementation(pc, false);
+    _builder.append(_portClassImplementation);
+    _builder.newLineIfNotEmpty();
+    CharSequence _portClassImplementation_1 = this.portClassImplementation(pc, true);
+    _builder.append(_portClassImplementation_1);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(pc);
+    _builder.append(_generateNamespaceEnd);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    return _builder;
+  }
+  
+  protected CharSequence portClassImplementation(final ProtocolClass pc, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      PortClass pclass = this.roomExt.getPortClass(pc, conj);
+      String portClassName = this.roomExt.getPortClassName(pc, conj);
+      String replPortClassName = this.roomExt.getPortClassName(pc, conj, true);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("// ");
+      {
+        if (conj) {
+          _builder.append("conjugated ");
+        }
+      }
+      _builder.append("port class");
+      _builder.newLineIfNotEmpty();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append(portClassName);
+      _builder.append("::");
+      _builder.append(portClassName);
+      _builder.append("(IInterfaceItemOwner* actor, const String& name, int localId)");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      CharSequence _generateConstructorInitalizerList = this.generateConstructorInitalizerList(pclass, "0");
+      _builder.append(_generateConstructorInitalizerList, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append(portClassName);
+      _builder.append("::");
+      _builder.append(portClassName);
+      _builder.append("(IInterfaceItemOwner* actor, const String& name, int localId, int idx)");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      CharSequence _generateConstructorInitalizerList_1 = this.generateConstructorInitalizerList(pclass, "idx");
+      _builder.append(_generateConstructorInitalizerList_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("\t");
+      {
+        boolean _notEquals = (!Objects.equal(pclass, null));
+        if (_notEquals) {
+          CharSequence _genExtraInitializers = this.initHelper.genExtraInitializers(pclass.getAttributes());
+          _builder.append(_genExtraInitializers, "\t");
+        }
+      }
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.newLine();
+          _builder.append("void ");
+          _builder.append(portClassName);
+          _builder.append("::destroy() {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().removePortInstance(*this);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("PortBase::destroy();");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      _builder.append(portClassName);
+      _builder.append("::receive(const Message* msg) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("// TODO JH further");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("if (! ");
+      String _name = pc.getName();
+      _builder.append(_name, "\t");
+      _builder.append("::");
+      {
+        if (conj) {
+          _builder.append("isValidOutgoingEvtID");
+        } else {
+          _builder.append("isValidIncomingEvtID");
+        }
+      }
+      _builder.append("(msg->getEvtId())) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("//std::cout << \"unknown\" << std::endl;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.append("\t");
+          _builder.append("DebuggingService::getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), ");
+          String _name_1 = pc.getName();
+          _builder.append(_name_1, "\t");
+          _builder.append("::getMessageString(msg->getEvtId()).c_str());");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _handlesReceive = this.roomExt.handlesReceive(pc, conj);
+        if (_handlesReceive) {
+          _builder.append("\t");
+          _builder.append("switch (msg->getEvtId()) {");
+          _builder.newLine();
+          {
+            List<MessageHandler> _receiveHandlers = this.roomExt.getReceiveHandlers(pc, conj);
+            for(final MessageHandler hdlr : _receiveHandlers) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("case ");
+              String _name_2 = pc.getName();
+              _builder.append(_name_2, "\t\t");
+              _builder.append("::");
+              String _codeName = this.roomExt.getCodeName(hdlr.getMsg());
+              _builder.append(_codeName, "\t\t");
+              _builder.append(":");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("{");
+              _builder.newLine();
+              {
+                EList<String> _lines = hdlr.getDetailCode().getLines();
+                for(final String command : _lines) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  _builder.append(command, "\t\t\t\t");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("break;");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("default:");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("getActor()->receiveEvent(this, msg->getEvtId(),\tmsg->getData());");
+      _builder.newLine();
+      {
+        boolean _handlesReceive_1 = this.roomExt.handlesReceive(pc, conj);
+        if (_handlesReceive_1) {
+          _builder.append("\t");
+          _builder.append("\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _notEquals_1 = (!Objects.equal(pclass, null));
+        if (_notEquals_1) {
+          CharSequence _operationsImplementation = this.helpers.operationsImplementation(pclass.getOperations(), portClassName);
+          _builder.append(_operationsImplementation);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("// sent messages");
+      _builder.newLine();
+      {
+        List<Message> _allMessages = this._roomHelpers.getAllMessages(pc, conj);
+        for(final Message m : _allMessages) {
+          CharSequence _sendMessage = this.sendMessage(m, pc.getName(), portClassName, conj);
+          _builder.append(_sendMessage);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append("// ");
+      {
+        if (conj) {
+          _builder.append("conjugated ");
+        }
+      }
+      _builder.append("replicated port class");
+      _builder.newLineIfNotEmpty();
+      _builder.append("//------------------------------------------------------------------------------------------------------------");
+      _builder.newLine();
+      _builder.append(replPortClassName);
+      _builder.append("::");
+      _builder.append(replPortClassName);
+      _builder.append("(IInterfaceItemOwner* actor, const String& name, int localId) :");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("ReplicatedPortBase(actor, name, localId)");
+      _builder.newLine();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        if (conj) {
+          _builder.append("// incoming messages");
+          _builder.newLine();
+          {
+            List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+            for(final Message m_1 : _allIncomingMessages) {
+              CharSequence _messageSignatureDefinition = this.messageSignatureDefinition(m_1, replPortClassName, false);
+              _builder.append(_messageSignatureDefinition);
+              _builder.append("{");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("for (Vector<etRuntime::InterfaceItemBase*>::iterator it = getItems().begin(); it != getItems().end(); ++it) {");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("(dynamic_cast<");
+              _builder.append(portClassName, "\t\t");
+              _builder.append("*>(*it))->");
+              CharSequence _messageCall = this.messageCall(m_1, false);
+              _builder.append(_messageCall, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        } else {
+          _builder.append("// outgoing messages");
+          _builder.newLine();
+          {
+            List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+            for(final Message m_2 : _allOutgoingMessages) {
+              CharSequence _messageSignatureDefinition_1 = this.messageSignatureDefinition(m_2, replPortClassName, false);
+              _builder.append(_messageSignatureDefinition_1);
+              _builder.append("{");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("for (Vector<etRuntime::InterfaceItemBase*>::iterator it = getItems().begin(); it != getItems().end(); ++it) {");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("(dynamic_cast<");
+              _builder.append(portClassName, "\t\t");
+              _builder.append("*>(*it))->");
+              CharSequence _messageCall_1 = this.messageCall(m_2, false);
+              _builder.append(_messageCall_1, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateConstructorInitalizerList(final PortClass pc, final String index) {
+    CharSequence _xblockexpression = null;
+    {
+      @Extension
+      final Initialization initHelper = this.initHelper;
+      final List<CharSequence> initList = CollectionLiterals.<CharSequence>newArrayList();
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("PortBase(actor, name, localId, ");
+      _builder.append(index);
+      _builder.append(")");
+      initList.add(_builder.toString());
+      boolean _notEquals = (!Objects.equal(pc, null));
+      if (_notEquals) {
+        final Function1<Attribute, String> _function = (Attribute it) -> {
+          StringConcatenation _builder_1 = new StringConcatenation();
+          String _name = it.getName();
+          _builder_1.append(_name);
+          _builder_1.append("(");
+          String _initializerListValue = initHelper.getInitializerListValue(it);
+          _builder_1.append(_initializerListValue);
+          _builder_1.append(")");
+          return _builder_1.toString();
+        };
+        List<String> _map = ListExtensions.<Attribute, String>map(pc.getAttributes(), _function);
+        Iterables.<CharSequence>addAll(initList, _map);
+      }
+      _xblockexpression = initHelper.generateCtorInitializerList(initList);
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence messageCall(final Message m, final boolean impl) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _name = m.getName();
+    _builder.append(_name);
+    {
+      if (impl) {
+        _builder.append("_impl");
+      }
+    }
+    _builder.append("(");
+    {
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        _builder.append(" ");
+        String _name_1 = m.getData().getName();
+        _builder.append(_name_1);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  protected CharSequence messageSignature(final Message m, final boolean impl) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      if ((m.isPriv() || impl)) {
+        _builder.append("private:");
+      } else {
+        _builder.append("public:");
+      }
+    }
+    _builder.append(" void ");
+    String _name = m.getName();
+    _builder.append(_name);
+    {
+      if (impl) {
+        _builder.append("_impl");
+      }
+    }
+    _builder.append("(");
+    {
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        String _signatureString = this.helpers.signatureString(m.getData().getRefType());
+        _builder.append(_signatureString);
+        _builder.append(" ");
+        String _name_1 = m.getData().getName();
+        _builder.append(_name_1);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  protected CharSequence messageSignatureDefinition(final Message m, final String classPrefix, final boolean impl) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("void ");
+    _builder.append(classPrefix);
+    _builder.append("::");
+    String _name = m.getName();
+    _builder.append(_name);
+    {
+      if (impl) {
+        _builder.append("_impl");
+      }
+    }
+    _builder.append("(");
+    {
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        String _signatureString = this.helpers.signatureString(m.getData().getRefType());
+        _builder.append(_signatureString);
+        _builder.append(" ");
+        String _name_1 = m.getData().getName();
+        _builder.append(_name_1);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  protected CharSequence sendMessage(final Message m, final String portClassName, final String classPrefix, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      String _xifexpression = null;
+      if (conj) {
+        _xifexpression = "IN";
+      } else {
+        _xifexpression = "OUT";
+      }
+      String dir = _xifexpression;
+      MessageHandler hdlr = this.roomExt.getSendHandler(m, conj);
+      String _xifexpression_1 = null;
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append(", ");
+        String _name = m.getData().getName();
+        _builder.append(_name);
+        _xifexpression_1 = _builder.toString();
+      }
+      final String dataArg = _xifexpression_1;
+      String _xifexpression_2 = null;
+      if (((!Objects.equal(m.getData(), null)) && (!m.getData().getRefType().isRef()))) {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        _builder_1.append("DataMessage<");
+        String _typeName = this._typeHelpers.typeName(m.getData().getRefType().getType());
+        _builder_1.append(_typeName);
+        _builder_1.append(">");
+        _xifexpression_2 = _builder_1.toString();
+      } else {
+        StringConcatenation _builder_2 = new StringConcatenation();
+        _builder_2.append("Message");
+        _xifexpression_2 = _builder_2.toString();
+      }
+      final String messageType = _xifexpression_2;
+      StringConcatenation _builder_3 = new StringConcatenation();
+      _builder_3.append("new (buffer) ");
+      _builder_3.append(messageType);
+      _builder_3.append("(getPeerAddress(), ");
+      _builder_3.append(portClassName);
+      _builder_3.append("::");
+      _builder_3.append(dir);
+      _builder_3.append("_");
+      String _name_1 = m.getName();
+      _builder_3.append(_name_1);
+      String _elvis = null;
+      if (dataArg != null) {
+        _elvis = dataArg;
+      } else {
+        _elvis = "";
+      }
+      _builder_3.append(_elvis);
+      _builder_3.append(")");
+      final String message = _builder_3.toString();
+      StringConcatenation _builder_4 = new StringConcatenation();
+      CharSequence _messageSignatureDefinition = this.messageSignatureDefinition(m, classPrefix, false);
+      _builder_4.append(_messageSignatureDefinition);
+      _builder_4.append(" {");
+      _builder_4.newLineIfNotEmpty();
+      {
+        boolean _notEquals_1 = (!Objects.equal(hdlr, null));
+        if (_notEquals_1) {
+          _builder_4.append("\t");
+          {
+            EList<String> _lines = hdlr.getDetailCode().getLines();
+            for(final String command : _lines) {
+              _builder_4.append("\t");
+              _builder_4.append(command, "\t");
+              _builder_4.newLineIfNotEmpty();
+            }
+          }
+        } else {
+          _builder_4.append("\t");
+          CharSequence _messageCall = this.messageCall(m, true);
+          _builder_4.append(_messageCall, "\t");
+          _builder_4.append(";");
+          _builder_4.newLineIfNotEmpty();
+        }
+      }
+      _builder_4.append("}");
+      _builder_4.newLine();
+      _builder_4.newLine();
+      CharSequence _messageSignatureDefinition_1 = this.messageSignatureDefinition(m, classPrefix, true);
+      _builder_4.append(_messageSignatureDefinition_1);
+      _builder_4.append(" {");
+      _builder_4.newLineIfNotEmpty();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder_4.append("\t");
+          _builder_4.append("DebuggingService::getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(),");
+          _builder_4.newLine();
+          _builder_4.append("\t");
+          _builder_4.append("\t");
+          _builder_4.append(portClassName, "\t\t");
+          _builder_4.append("::getMessageString(");
+          _builder_4.append(portClassName, "\t\t");
+          _builder_4.append("::");
+          _builder_4.append(dir, "\t\t");
+          _builder_4.append("_");
+          String _name_2 = m.getName();
+          _builder_4.append(_name_2, "\t\t");
+          _builder_4.append(").c_str());");
+          _builder_4.newLineIfNotEmpty();
+        }
+      }
+      _builder_4.append("\t");
+      _builder_4.append("if (getPeerAddress().isValid()) {");
+      _builder_4.newLine();
+      _builder_4.append("\t\t");
+      _builder_4.append("Message* buffer = dynamic_cast<IMessageService*>(getPeerMsgReceiver())->getMessageBuffer(sizeof(");
+      _builder_4.append(messageType, "\t\t");
+      _builder_4.append("));");
+      _builder_4.newLineIfNotEmpty();
+      _builder_4.append("\t\t");
+      _builder_4.append("if (buffer) {");
+      _builder_4.newLine();
+      _builder_4.append("\t\t\t");
+      _builder_4.append("getPeerMsgReceiver()->receive(");
+      _builder_4.append(message, "\t\t\t");
+      _builder_4.append(");");
+      _builder_4.newLineIfNotEmpty();
+      _builder_4.append("\t\t");
+      _builder_4.append("}");
+      _builder_4.newLine();
+      _builder_4.append("\t");
+      _builder_4.append("}");
+      _builder_4.newLine();
+      _builder_4.append("}");
+      _builder_4.newLine();
+      _xblockexpression = _builder_4;
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence generateDataDrivenHeaderFile(final Root root, final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      final Iterable<Message> sentMsgs = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Header File of ProtocolClass ");
+      String _name = pc.getName();
+      _builder.append(_name, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardBegin = this.stdExt.generateIncludeGuardBegin(pc, "");
+      _builder.append(_generateIncludeGuardBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("#include \"common/etDatatypesCpp.hpp\"");
+      _builder.newLine();
+      _builder.append("#include \"common/modelbase/DataPort.h\"");
+      _builder.newLine();
+      {
+        EList<DataClass> _referencedDataClasses = root.getReferencedDataClasses(pc);
+        for(final DataClass dataClass : _referencedDataClasses) {
+          _builder.append("#include \"");
+          String _path = this.roomExt.getPath(dataClass);
+          _builder.append(_path);
+          String _name_1 = dataClass.getName();
+          _builder.append(_name_1);
+          _builder.append(".h\"");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this.helpers.userCode(pc.getUserCode1());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(pc);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("class ");
+      String _name_2 = pc.getName();
+      _builder.append(_name_2);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _userCode_1 = this.helpers.userCode(pc.getUserCode2());
+      _builder.append(_userCode_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// send port holds data");
+      _builder.newLine();
+      _builder.append("class ");
+      String _portClassName = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName);
+      _builder.append(" : public etRuntime::DataSendPort {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t");
+      String _portClassName_1 = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName_1, "\t");
+      _builder.append("(etRuntime::IRTObject* parent, const etRuntime::String& name, int localId);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// getters and setters");
+      _builder.newLine();
+      {
+        for(final Message msg : sentMsgs) {
+          _builder.append("\t");
+          _builder.append("void ");
+          String _name_3 = msg.getName();
+          _builder.append(_name_3, "\t");
+          _builder.append("(");
+          String _typeName = this._typeHelpers.typeName(msg.getData().getRefType().getType());
+          _builder.append(_typeName, "\t");
+          _builder.append(" ");
+          String _name_4 = msg.getName();
+          _builder.append(_name_4, "\t");
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("m_");
+          String _name_5 = msg.getName();
+          _builder.append(_name_5, "\t\t");
+          _builder.append(" = ");
+          String _name_6 = msg.getName();
+          _builder.append(_name_6, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          String _typeName_1 = this._typeHelpers.typeName(msg.getData().getRefType().getType());
+          _builder.append(_typeName_1, "\t");
+          _builder.append(" ");
+          String _name_7 = msg.getName();
+          _builder.append(_name_7, "\t");
+          _builder.append("() const {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("return m_");
+          String _name_8 = msg.getName();
+          _builder.append(_name_8, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("private:");
+      _builder.newLine();
+      {
+        for(final Message msg_1 : sentMsgs) {
+          _builder.append("\t");
+          String _typeName_2 = this._typeHelpers.typeName(msg_1.getData().getRefType().getType());
+          _builder.append(_typeName_2, "\t");
+          _builder.append(" m_");
+          String _name_9 = msg_1.getName();
+          _builder.append(_name_9, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// receive port accesses send port");
+      _builder.newLine();
+      _builder.append("class ");
+      String _portClassName_2 = this.roomExt.getPortClassName(pc, false);
+      _builder.append(_portClassName_2);
+      _builder.append(" : public etRuntime::DataReceivePort {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("public:");
+      _builder.newLine();
+      _builder.append("\t");
+      String _portClassName_3 = this.roomExt.getPortClassName(pc, false);
+      _builder.append(_portClassName_3, "\t");
+      _builder.append("(etRuntime::IRTObject* parent, const etRuntime::String& name, int localId);");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// getters");
+      _builder.newLine();
+      {
+        for(final Message msg_2 : sentMsgs) {
+          _builder.append("\t");
+          String _typeName_3 = this._typeHelpers.typeName(msg_2.getData().getRefType().getType());
+          _builder.append(_typeName_3, "\t");
+          _builder.append(" ");
+          String _name_10 = msg_2.getName();
+          _builder.append(_name_10, "\t");
+          _builder.append("() const;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("protected:");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("virtual void connect(etRuntime::DataSendPort* dataSendPort);");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("private:");
+      _builder.newLine();
+      _builder.append("\t");
+      String _portClassName_4 = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName_4, "\t");
+      _builder.append("* m_peer;");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(pc);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _generateIncludeGuardEnd = this.stdExt.generateIncludeGuardEnd(pc, "");
+      _builder.append(_generateIncludeGuardEnd);
+      _builder.newLineIfNotEmpty();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  protected CharSequence generateDataDrivenSourceFile(final Root root, final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      final Iterable<Message> sentMsgs = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @author generated by eTrice");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* Source File of ProtocolClass ");
+      String _name = pc.getName();
+      _builder.append(_name, " ");
+      _builder.newLineIfNotEmpty();
+      _builder.append(" ");
+      _builder.append("*");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("#include \"");
+      String _cppHeaderFileName = this.stdExt.getCppHeaderFileName(pc);
+      _builder.append(_cppHeaderFileName);
+      _builder.append("\"");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("using namespace etRuntime;");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceBegin = this.stdExt.generateNamespaceBegin(pc);
+      _builder.append(_generateNamespaceBegin);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      CharSequence _userCode = this.helpers.userCode(pc.getUserCode3());
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("// send port holds data");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// constructor");
+      _builder.newLine();
+      String _portClassName = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName);
+      _builder.append("::");
+      String _portClassName_1 = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName_1);
+      _builder.append("(IRTObject* parent, const String& name, int localId) :");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("DataSendPort(parent, name, localId)");
+      _builder.newLine();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// receive port accesses send port");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// constructor");
+      _builder.newLine();
+      String _portClassName_2 = this.roomExt.getPortClassName(pc, false);
+      _builder.append(_portClassName_2);
+      _builder.append("::");
+      String _portClassName_3 = this.roomExt.getPortClassName(pc, false);
+      _builder.append(_portClassName_3);
+      _builder.append("(IRTObject* parent, const String& name, int localId) :");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("DataReceivePort(parent, name, localId),");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("m_peer(0)");
+      _builder.newLine();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// getters");
+      _builder.newLine();
+      {
+        for(final Message msg : sentMsgs) {
+          String _typeName = this._typeHelpers.typeName(msg.getData().getRefType().getType());
+          _builder.append(_typeName);
+          _builder.append(" ");
+          String _portClassName_4 = this.roomExt.getPortClassName(pc, false);
+          _builder.append(_portClassName_4);
+          _builder.append("::");
+          String _name_1 = msg.getName();
+          _builder.append(_name_1);
+          _builder.append("() const {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("// TODO needs default value");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("//if (m_peer == 0)");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("/*\treturn ");
+          String _defaultValue = this.stdExt.defaultValue(msg.getData().getRefType().getType());
+          _builder.append(_defaultValue, "\t");
+          _builder.append("; */");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("return m_peer->");
+          String _name_2 = msg.getName();
+          _builder.append(_name_2, "\t");
+          _builder.append("();");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("void ");
+      String _portClassName_5 = this.roomExt.getPortClassName(pc, false);
+      _builder.append(_portClassName_5);
+      _builder.append("::connect(DataSendPort* dataSendPort) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      String _portClassName_6 = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName_6, "\t");
+      _builder.append("* peer = dynamic_cast<");
+      String _portClassName_7 = this.roomExt.getPortClassName(pc, true);
+      _builder.append(_portClassName_7, "\t");
+      _builder.append("*>(dataSendPort);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("if (peer != 0)");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("m_peer = peer;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      String _generateNamespaceEnd = this.stdExt.generateNamespaceEnd(pc);
+      _builder.append(_generateNamespaceEnd);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getMessageID(final Message msg, final InterfaceItem item) {
+    if ((item instanceof Port)) {
+      Port p = ((Port) item);
+      String _xifexpression = null;
+      boolean _isConjugated = p.isConjugated();
+      if (_isConjugated) {
+        _xifexpression = "OUT_";
+      } else {
+        _xifexpression = "IN_";
+      }
+      String direction = _xifexpression;
+      String _name = p.getProtocol().getName();
+      String _name_1 = msg.getName();
+      String _plus = (direction + _name_1);
+      return this.enumInUse(_name, _plus);
+    } else {
+      if ((item instanceof SAP)) {
+        SAP sap = ((SAP) item);
+        String _name_2 = sap.getProtocol().getName();
+        String _name_3 = msg.getName();
+        String _plus_1 = ("OUT_" + _name_3);
+        return this.enumInUse(_name_2, _plus_1);
+      } else {
+        if ((item instanceof SPP)) {
+          SPP spp = ((SPP) item);
+          String _name_4 = spp.getProtocol().getName();
+          String _name_5 = msg.getName();
+          String _plus_2 = ("IN_" + _name_5);
+          return this.enumInUse(_name_4, _plus_2);
+        }
+      }
+    }
+    return "unknown interface item";
+  }
+  
+  protected String enumInUse(final String namespace, final String member) {
+    return ((namespace + "::") + member);
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.java b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.java
new file mode 100644
index 000000000..c751e2cb7
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.cpp/xtend-gen/org/eclipse/etrice/generator/cpp/gen/StateMachineGen.java
@@ -0,0 +1,182 @@
+/**
+ * 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)
+ * 		Peter Karlitschek
+ */
+package org.eclipse.etrice.generator.cpp.gen;
+
+import com.google.inject.Singleton;
+import java.util.Comparator;
+import java.util.List;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+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.Node;
+import org.eclipse.etrice.generator.cpp.Main;
+import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class StateMachineGen extends GenericStateMachineGenerator {
+  private static class NodeComparator implements Comparator<Node> {
+    @Override
+    public int compare(final Node o1, final Node o2) {
+      int _inheritanceLevel = o1.getInheritanceLevel();
+      int _inheritanceLevel_1 = o2.getInheritanceLevel();
+      boolean _equals = (_inheritanceLevel == _inheritanceLevel_1);
+      if (_equals) {
+        if ((FsmGenExtensions.isLeaf(o1) && FsmGenExtensions.isLeaf(o2))) {
+          return 0;
+        }
+        boolean _isLeaf = FsmGenExtensions.isLeaf(o1);
+        if (_isLeaf) {
+          return 1;
+        }
+        boolean _isLeaf_1 = FsmGenExtensions.isLeaf(o2);
+        if (_isLeaf_1) {
+          return (-1);
+        }
+        return 0;
+      } else {
+        return Integer.compare(o1.getInheritanceLevel(), o1.getInheritanceLevel());
+      }
+    }
+  }
+  
+  private final StateMachineGen.NodeComparator nodeComparator = new StateMachineGen.NodeComparator();
+  
+  @Override
+  public CharSequence genExtra(final GraphContainer gc, final boolean generateImplementation) {
+    CharSequence _xblockexpression = null;
+    {
+      ModelComponent ac = gc.getComponent();
+      final String clsName = ac.getComponentName();
+      final List<Node> orderedStateNodes = IterableExtensions.<Node>sortWith(IteratorExtensions.<Node>toList(FsmGenExtensions.getAllStateNodes(gc.getGraph())), this.nodeComparator);
+      CharSequence _xifexpression = null;
+      if (generateImplementation) {
+        StringConcatenation _builder = new StringConcatenation();
+        {
+          if ((Main.getSettings().isGenerateMSCInstrumentation() || Main.getSettings().isGenerateWithVerboseOutput())) {
+            _builder.append("// state names");
+            _builder.newLine();
+            _builder.append("const String ");
+            _builder.append(clsName);
+            _builder.append("::s_stateStrings[] = {");
+            _builder.newLineIfNotEmpty();
+            _builder.append("\t");
+            _builder.append("\"<no state>\",");
+            _builder.newLine();
+            _builder.append("\t");
+            _builder.append("\"<top>\",");
+            _builder.newLine();
+            {
+              boolean _hasElements = false;
+              for(final Node state : orderedStateNodes) {
+                if (!_hasElements) {
+                  _hasElements = true;
+                } else {
+                  _builder.appendImmediate(",", "\t");
+                }
+                _builder.append("\t");
+                _builder.append("\"");
+                StateGraphNode _stateGraphNode = state.getStateGraphNode();
+                String _genStatePathName = this._codegenHelpers.getGenStatePathName(((State) _stateGraphNode));
+                _builder.append(_genStatePathName, "\t");
+                _builder.append("\"");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+            _builder.append("};");
+            _builder.newLine();
+          }
+        }
+        _builder.append("const int ");
+        _builder.append(clsName);
+        _builder.append("::s_numberOfStates = ");
+        int _size = orderedStateNodes.size();
+        int _plus = (2 + _size);
+        _builder.append(_plus);
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.newLine();
+        _builder.append("void ");
+        _builder.append(clsName);
+        _builder.append("::setState(int new_state) {");
+        _builder.newLineIfNotEmpty();
+        {
+          boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+          if (_isGenerateMSCInstrumentation) {
+            _builder.append("\t");
+            _builder.append("DebuggingService::getInstance().addActorState(*this, s_stateStrings[new_state].c_str());");
+            _builder.newLine();
+          }
+        }
+        {
+          boolean _isGenerateWithVerboseOutput = Main.getSettings().isGenerateWithVerboseOutput();
+          if (_isGenerateWithVerboseOutput) {
+            _builder.append("\t");
+            _builder.append("if (s_stateStrings[new_state] != \"Idle\") {");
+            _builder.newLine();
+            _builder.append("\t");
+            _builder.append("\t");
+            _builder.append("std::cout << getInstancePath().c_str() << \" -> \" << s_stateStrings[new_state].c_str() << std::endl;");
+            _builder.newLine();
+            _builder.append("\t");
+            _builder.append("}");
+            _builder.newLine();
+          }
+        }
+        _builder.append("\t");
+        _builder.append("m_state = new_state;");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+        _xifexpression = _builder;
+      } else {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        {
+          if ((Main.getSettings().isGenerateMSCInstrumentation() || Main.getSettings().isGenerateWithVerboseOutput())) {
+            _builder_1.append("static const String s_stateStrings[];");
+            _builder_1.newLine();
+          }
+        }
+        _builder_1.append("static const int s_numberOfStates;");
+        _builder_1.newLine();
+        _builder_1.newLine();
+        _builder_1.append("int history[");
+        int _size_1 = orderedStateNodes.size();
+        int _plus_1 = (2 + _size_1);
+        _builder_1.append(_plus_1);
+        _builder_1.append("];");
+        _builder_1.newLineIfNotEmpty();
+        _builder_1.newLine();
+        _builder_1.append("void setState(int new_state);");
+        _builder_1.newLine();
+        _xifexpression = _builder_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String stateType() {
+    return "etInt16";
+  }
+  
+  @Override
+  public String boolType() {
+    return "etBool";
+  }
+}
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..35d6e3312 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 {
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.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/DocGen.java b/plugins/org.eclipse.etrice.generator.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/DocGen.java
new file mode 100644
index 000000000..4ca0a71ca
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/DocGen.java
@@ -0,0 +1,1473 @@
+/**
+ * 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:
+ * 		Thomas Jung, Thomas Schuetz (initial contribution)
+ */
+package org.eclipse.etrice.generator.doc.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.common.base.Documentation;
+import org.eclipse.etrice.core.common.base.util.RelativePathHelpers;
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+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.CompoundProtocolClass;
+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.GeneralProtocolClass;
+import org.eclipse.etrice.core.room.LogicalSystem;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.PrimitiveType;
+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.RoomModel;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.SubProtocol;
+import org.eclipse.etrice.core.room.SubSystemClass;
+import org.eclipse.etrice.core.room.VarDecl;
+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.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class DocGen {
+  public static class DocGenContext {
+    private final Root root;
+    
+    private final RoomModel model;
+    
+    public DocGenContext(final Root r, final RoomModel m) {
+      this.root = r;
+      this.model = m;
+    }
+  }
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private CodegenHelpers _codegenHelpers;
+  
+  @Inject
+  @Extension
+  private JavaIoFileSystemAccess fileAccess;
+  
+  @Inject
+  @Extension
+  private RoomExtensions roomExt;
+  
+  @Inject
+  private ILogger logger;
+  
+  private final String IMGDIR_DEFAULT = "./images";
+  
+  private final String IMGWIDTH_DEFAULT = "1.0\\textwidth";
+  
+  public void doGenerate(final Root root) {
+    EList<RoomModel> _models = root.getModels();
+    for (final RoomModel model : _models) {
+      {
+        final DocGen.DocGenContext ctx = new DocGen.DocGenContext(root, model);
+        String path = this.roomExt.getDocGenerationTargetPath(model);
+        String _name = model.getName();
+        String file = (_name + ".tex");
+        final Set<RoomModel> referencedModels = CollectionLiterals.<RoomModel>newHashSet();
+        this.logger.logInfo((((("generating LaTeX documentation: \'" + file) + "\' in \'") + path) + "\'"));
+        String _name_1 = model.getName();
+        String _plus = (path + _name_1);
+        this.fileAccess.setOutputPath(_plus);
+        final Consumer<LogicalSystem> _function = (LogicalSystem it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getSystems().forEach(_function);
+        final Consumer<LogicalSystem> _function_1 = (LogicalSystem it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getSystems().forEach(_function_1);
+        final Consumer<SubSystemClass> _function_2 = (SubSystemClass it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getSubSystemClasses().forEach(_function_2);
+        final Consumer<SubSystemClass> _function_3 = (SubSystemClass it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getSubSystemClasses().forEach(_function_3);
+        final Consumer<GeneralProtocolClass> _function_4 = (GeneralProtocolClass it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getProtocolClasses().forEach(_function_4);
+        final Consumer<GeneralProtocolClass> _function_5 = (GeneralProtocolClass it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getProtocolClasses().forEach(_function_5);
+        final Consumer<EnumerationType> _function_6 = (EnumerationType it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getEnumerationTypes().forEach(_function_6);
+        final Consumer<EnumerationType> _function_7 = (EnumerationType it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getEnumerationTypes().forEach(_function_7);
+        final Consumer<DataClass> _function_8 = (DataClass it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getDataClasses().forEach(_function_8);
+        final Consumer<DataClass> _function_9 = (DataClass it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getDataClasses().forEach(_function_9);
+        final Consumer<ActorClass> _function_10 = (ActorClass it) -> {
+          this.saveAs(this.generateDoc(it, ctx), this.docFragmentName(it));
+        };
+        model.getActorClasses().forEach(_function_10);
+        final Consumer<ActorClass> _function_11 = (ActorClass it) -> {
+          referencedModels.addAll(root.getReferencedModels(it));
+        };
+        model.getActorClasses().forEach(_function_11);
+        this.fileAccess.setOutputPath(path);
+        this.saveAs(this.generateModelDoc(ctx, referencedModels), file);
+      }
+    }
+  }
+  
+  private String removeLast(final String str) {
+    int _length = str.length();
+    int _minus = (_length - 1);
+    return str.substring(0, _minus);
+  }
+  
+  private String appendIfNotEmpty(final String txt, final String suffix) {
+    String _xifexpression = null;
+    boolean _isEmpty = txt.isEmpty();
+    if (_isEmpty) {
+      _xifexpression = txt;
+    } else {
+      _xifexpression = (txt + suffix);
+    }
+    return _xifexpression;
+  }
+  
+  private CharSequence generateModelDoc(final DocGen.DocGenContext ctx, final Set<RoomModel> referencedModels) {
+    CharSequence _xblockexpression = null;
+    {
+      RoomModel model = ctx.model;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\documentclass[titlepage]{article}");
+      _builder.newLine();
+      _builder.append("\\usepackage{import}");
+      _builder.newLine();
+      _builder.append("\\usepackage{graphicx}");
+      _builder.newLine();
+      _builder.append("\\usepackage{xr}");
+      _builder.newLine();
+      _builder.append("\\usepackage{hyperref}");
+      _builder.newLine();
+      _builder.append("\\IfFileExists{../doc/userinputs.tex}{\\subimport{../doc/}{userinputs.tex}}{} %hook for conditional user-specific inputs, includes, macros, ... ");
+      _builder.newLine();
+      _builder.append("\\usepackage[a4paper,text={160mm,255mm},centering,headsep=5mm,footskip=10mm]{geometry}");
+      _builder.newLine();
+      _builder.append("\\usepackage{nonfloat}");
+      _builder.newLine();
+      _builder.append("\\parindent 0pt");
+      _builder.newLine();
+      _builder.append("\\makeatletter");
+      _builder.newLine();
+      _builder.append("\\newcommand\\level[1]{%");
+      _builder.newLine();
+      _builder.append("   ");
+      _builder.append("\\ifcase#1\\relax\\expandafter\\chapter\\or");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\expandafter\\section\\or");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\expandafter\\subsection\\or");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\expandafter\\subsubsection\\else");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\def\\next{\\@level{#1}}\\expandafter\\next");
+      _builder.newLine();
+      _builder.append("   ");
+      _builder.append("\\fi}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\newcommand{\\@level}[1]{%");
+      _builder.newLine();
+      _builder.append("\\@startsection{level#1}");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("{#1}");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("{\\z@}%");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("{-3.25ex\\@plus -1ex \\@minus -.2ex}%");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("{1.5ex \\@plus .2ex}%");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("{\\normalfont\\normalsize\\bfseries}}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\newdimen\\@leveldim");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\newdimen\\@dotsdim");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("{\\normalfont\\normalsize");
+      _builder.newLine();
+      _builder.append("  ");
+      _builder.append("\\sbox\\z@{0}\\global\\@leveldim=\\wd\\z@");
+      _builder.newLine();
+      _builder.append("  ");
+      _builder.append("\\sbox\\z@{.}\\global\\@dotsdim=\\wd\\z@");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("}  ");
+      _builder.newLine();
+      _builder.append("\\newcounter{level4}[subsubsection]");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\@namedef{thelevel4}{\\thesubsubsection.\\arabic{level4}}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\@namedef{level4mark}#1{}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\def\\l@section{\\@dottedtocline{1}{0pt}{\\dimexpr\\@leveldim*4+\\@dotsdim*1+6pt\\relax}}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\def\\l@subsection{\\@dottedtocline{2}{0pt}{\\dimexpr\\@leveldim*5+\\@dotsdim*2+6pt\\relax}}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\def\\l@subsubsection{\\@dottedtocline{3}{0pt}{\\dimexpr\\@leveldim*6+\\@dotsdim*3+6pt\\relax}}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\@namedef{l@level4}{\\@dottedtocline{4}{0pt}{\\dimexpr\\@leveldim*7+\\@dotsdim*4+6pt\\relax}}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\count@=4");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\def\\@ncp#1{\\number\\numexpr\\count@+#1\\relax}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\loop\\ifnum\\count@<100");
+      _builder.newLine();
+      _builder.append("   ");
+      _builder.append("\\begingroup\\edef\\x{\\endgroup");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\noexpand\\newcounter{level\\@ncp{1}}[level\\number\\count@]");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\noexpand\\@namedef{thelevel\\@ncp{1}}{%");
+      _builder.newLine();
+      _builder.append("       ");
+      _builder.append("\\noexpand\\@nameuse{thelevel\\@ncp{0}}.\\noexpand\\arabic{level\\@ncp{0}}}");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\noexpand\\@namedef{level\\@ncp{1}mark}####1{}%");
+      _builder.newLine();
+      _builder.append("     ");
+      _builder.append("\\noexpand\\@namedef{l@level\\@ncp{1}}%");
+      _builder.newLine();
+      _builder.append("       ");
+      _builder.append("{\\noexpand\\@dottedtocline{\\@ncp{1}}{0pt}{\\the\\dimexpr\\@leveldim*\\@ncp{5}+\\@dotsdim*\\@ncp{0}\\relax}}}%");
+      _builder.newLine();
+      _builder.append("   ");
+      _builder.append("\\x");
+      _builder.newLine();
+      _builder.append("   ");
+      _builder.append("\\advance\\count@\\@ne");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\repeat");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\makeatother");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\setcounter{secnumdepth}{100}");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("\\setcounter{tocdepth}{100}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\title{");
+      String _escapedString = this.escapedString(model.getName());
+      _builder.append(_escapedString);
+      _builder.append(" Model Documentation}");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\\date{\\today}");
+      _builder.newLine();
+      _builder.append("\\author{generated by eTrice}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\begin{document}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\pagestyle{plain}");
+      _builder.newLine();
+      _builder.append("\\maketitle");
+      _builder.newLine();
+      _builder.append("\\tableofcontents");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\\newpage");
+      _builder.newLine();
+      _builder.append("\\listoffigures");
+      _builder.newLine();
+      _builder.append("\\newpage");
+      _builder.newLine();
+      _builder.append("\\section{Model Description}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _isEmpty = referencedModels.isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("\\section{Referenced Models}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\\begin{itemize}");
+          _builder.newLine();
+          {
+            final Function1<RoomModel, String> _function = (RoomModel it) -> {
+              return it.getName();
+            };
+            List<RoomModel> _sortBy = IterableExtensions.<RoomModel, String>sortBy(referencedModels, _function);
+            for(final RoomModel refModel : _sortBy) {
+              final String relPath = this.appendIfNotEmpty(RelativePathHelpers.getRelativePath(
+                this.removeLast(this.roomExt.getDocGenerationTargetPath(model)), this.removeLast(this.roomExt.getDocGenerationTargetPath(refModel)), true), "/");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\item \\href{");
+              String _replace = relPath.replace("\\", "/");
+              String _name = refModel.getName();
+              String _escapedString_1 = this.escapedString((_replace + _name));
+              _builder.append(_escapedString_1);
+              _builder.append(".pdf}{");
+              String _escapedString_2 = this.escapedString(refModel.getName());
+              _builder.append(_escapedString_2);
+              _builder.append("}");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\end{itemize}");
+          _builder.newLine();
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_1 = model.getSystems().isEmpty();
+        boolean _not_1 = (!_isEmpty_1);
+        if (_not_1) {
+          _builder.append("\\section{Logical System Classes}");
+          _builder.newLine();
+          {
+            EList<LogicalSystem> _systems = model.getSystems();
+            for(final LogicalSystem s : _systems) {
+              CharSequence _generateImport = this.generateImport(s, model.getName());
+              _builder.append(_generateImport);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_2 = model.getSubSystemClasses().isEmpty();
+        boolean _not_2 = (!_isEmpty_2);
+        if (_not_2) {
+          _builder.append("\\section{Subsystem Classes}");
+          _builder.newLine();
+          {
+            EList<SubSystemClass> _subSystemClasses = model.getSubSystemClasses();
+            for(final SubSystemClass s_1 : _subSystemClasses) {
+              CharSequence _generateImport_1 = this.generateImport(s_1, model.getName());
+              _builder.append(_generateImport_1);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_3 = model.getProtocolClasses().isEmpty();
+        boolean _not_3 = (!_isEmpty_3);
+        if (_not_3) {
+          _builder.append("\\section{Protocol Classes}");
+          _builder.newLine();
+          {
+            EList<GeneralProtocolClass> _protocolClasses = model.getProtocolClasses();
+            for(final GeneralProtocolClass c : _protocolClasses) {
+              CharSequence _generateImport_2 = this.generateImport(c, model.getName());
+              _builder.append(_generateImport_2);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_4 = model.getEnumerationTypes().isEmpty();
+        boolean _not_4 = (!_isEmpty_4);
+        if (_not_4) {
+          _builder.append("\\section{Enumeration Types}");
+          _builder.newLine();
+          {
+            EList<EnumerationType> _enumerationTypes = model.getEnumerationTypes();
+            for(final EnumerationType e : _enumerationTypes) {
+              CharSequence _generateImport_3 = this.generateImport(e, model.getName());
+              _builder.append(_generateImport_3);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_5 = model.getDataClasses().isEmpty();
+        boolean _not_5 = (!_isEmpty_5);
+        if (_not_5) {
+          _builder.append("\\section{Data Classes}");
+          _builder.newLine();
+          {
+            EList<DataClass> _dataClasses = model.getDataClasses();
+            for(final DataClass c_1 : _dataClasses) {
+              CharSequence _generateImport_4 = this.generateImport(c_1, model.getName());
+              _builder.append(_generateImport_4);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\\newpage");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_6 = model.getActorClasses().isEmpty();
+        boolean _not_6 = (!_isEmpty_6);
+        if (_not_6) {
+          _builder.append("\\section{Actor Classes}");
+          _builder.newLine();
+          {
+            EList<ActorClass> _actorClasses = model.getActorClasses();
+            for(final ActorClass c_2 : _actorClasses) {
+              CharSequence _generateImport_5 = this.generateImport(c_2, model.getName());
+              _builder.append(_generateImport_5);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("\\end{document}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence _generateDoc(final LogicalSystem system, final DocGen.DocGenContext ctx) {
+    CharSequence _xblockexpression = null;
+    {
+      String _name = system.getName();
+      final String filename = (_name + "_instanceTree.jpg");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\level{2}{");
+      String _escapedString = this.escapedString(system.getName());
+      _builder.append(_escapedString);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      CharSequence _generateDocText = this.generateDocText(system.getDocu());
+      _builder.append(_generateDocText);
+      _builder.newLineIfNotEmpty();
+      _builder.append("\\level{3}{Instance Tree}");
+      _builder.newLine();
+      {
+        boolean _equals = this.fileExists(ctx.model, this.getImagePath(filename)).equals("true");
+        if (_equals) {
+          String _imagePath = this.getImagePath(filename);
+          String _name_1 = system.getName();
+          String _plus = (_name_1 + " Instance Tree");
+          CharSequence _includeGraphics = this.includeGraphics(_imagePath, this.IMGWIDTH_DEFAULT, _plus);
+          _builder.append(_includeGraphics);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence _generateDoc(final SubSystemClass ssc, final DocGen.DocGenContext ctx) {
+    CharSequence _xblockexpression = null;
+    {
+      String _escapedString = this.escapedString(ssc.getName());
+      final String filename = (_escapedString + "_structure.jpg");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\level{2}{");
+      String _escapedString_1 = this.escapedString(ssc.getName());
+      _builder.append(_escapedString_1);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      CharSequence _generateDocText = this.generateDocText(ssc.getDocu());
+      _builder.append(_generateDocText);
+      _builder.newLineIfNotEmpty();
+      _builder.append("\\level{3}{Structure}");
+      _builder.newLine();
+      {
+        boolean _equals = this.fileExists(ctx.model, this.getImagePath(filename)).equals("true");
+        if (_equals) {
+          String _imagePath = this.getImagePath(filename);
+          String _name = ssc.getName();
+          String _plus = (_name + " Structure");
+          CharSequence _includeGraphics = this.includeGraphics(_imagePath, this.IMGWIDTH_DEFAULT, _plus);
+          _builder.append(_includeGraphics);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence _generateDoc(final EnumerationType dc, final DocGen.DocGenContext ctx) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\level{2} {");
+    String _escapedString = this.escapedString(dc.getName());
+    _builder.append(_escapedString);
+    _builder.append("}");
+    _builder.newLineIfNotEmpty();
+    CharSequence _generateDocText = this.generateDocText(dc.getDocu());
+    _builder.append(_generateDocText);
+    _builder.newLineIfNotEmpty();
+    {
+      PrimitiveType _primitiveType = dc.getPrimitiveType();
+      boolean _notEquals = (!Objects.equal(_primitiveType, null));
+      if (_notEquals) {
+        _builder.append("The literals of this enumeration are based on PrimitiveType ");
+        String _escapedString_1 = this.escapedString(dc.getPrimitiveType().getName());
+        _builder.append(_escapedString_1);
+        _builder.append(".");
+        _builder.newLineIfNotEmpty();
+      } else {
+        _builder.append("The literals of this enumeration are of type \\texttt{int}.");
+        _builder.newLine();
+      }
+    }
+    _builder.append("\\level{3}{Literals}");
+    _builder.newLine();
+    _builder.append("\\begin{tabular}[ht]{|l|r|r|r|}");
+    _builder.newLine();
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\textbf{Name} & \\textbf{Value} & \\textbf{Hex Value} & \\textbf{Binary Value}\\\\");
+    _builder.newLine();
+    {
+      EList<EnumLiteral> _literals = dc.getLiterals();
+      for(final EnumLiteral lit : _literals) {
+        _builder.append("\\hline");
+        _builder.newLine();
+        String _escapedString_2 = this.escapedString(lit.getName());
+        _builder.append(_escapedString_2);
+        _builder.append(" & ");
+        long _literalValue = lit.getLiteralValue();
+        _builder.append(_literalValue);
+        _builder.append(" & 0x");
+        String _hexString = Long.toHexString(lit.getLiteralValue());
+        _builder.append(_hexString);
+        _builder.append(" & ");
+        String _binaryString = Long.toBinaryString(lit.getLiteralValue());
+        _builder.append(_binaryString);
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\end{tabular}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence _generateDoc(final DataClass dc, final DocGen.DocGenContext ctx) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\level{2} {");
+    String _escapedString = this.escapedString(dc.getName());
+    _builder.append(_escapedString);
+    _builder.append("}");
+    _builder.newLineIfNotEmpty();
+    CharSequence _generateDocText = this.generateDocText(dc.getDocu());
+    _builder.append(_generateDocText);
+    _builder.newLineIfNotEmpty();
+    _builder.append("\\level{3}{Attributes}");
+    _builder.newLine();
+    CharSequence _generateAttributesDoc = this.generateAttributesDoc(dc.getAttributes());
+    _builder.append(_generateAttributesDoc);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\\level{3}{Operations}");
+    _builder.newLine();
+    CharSequence _generateOperationsDoc = this.generateOperationsDoc(dc.getOperations());
+    _builder.append(_generateOperationsDoc);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  private CharSequence _generateDoc(final ProtocolClass pc, final DocGen.DocGenContext ctx) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\level{2} {");
+    String _escapedString = this.escapedString(pc.getName());
+    _builder.append(_escapedString);
+    _builder.append("}");
+    _builder.newLineIfNotEmpty();
+    CharSequence _generateDocText = this.generateDocText(pc.getDocu());
+    _builder.append(_generateDocText);
+    _builder.newLineIfNotEmpty();
+    {
+      boolean _isEmpty = this._roomHelpers.getAllIncomingMessages(pc).isEmpty();
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        _builder.append("\\level{3}{Incoming Messages}");
+        _builder.newLine();
+        _builder.newLine();
+        _builder.append("\\begin{tabular}[ht]{|l|l|l|p{8cm}|}");
+        _builder.newLine();
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("Message & Data & Type & Description\\\\");
+        _builder.newLine();
+        {
+          List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+          for(final Message ims : _allIncomingMessages) {
+            _builder.append("\\hline");
+            _builder.newLine();
+            String _escapedString_1 = this.escapedString(ims.getName());
+            _builder.append(_escapedString_1);
+            _builder.append(" & ");
+            {
+              VarDecl _data = ims.getData();
+              boolean _notEquals = (!Objects.equal(_data, null));
+              if (_notEquals) {
+                _builder.append(" ");
+                String _escapedString_2 = this.escapedString(ims.getData().getName());
+                _builder.append(_escapedString_2);
+                _builder.append(" ");
+              }
+            }
+            _builder.append(" & ");
+            {
+              VarDecl _data_1 = ims.getData();
+              boolean _notEquals_1 = (!Objects.equal(_data_1, null));
+              if (_notEquals_1) {
+                _builder.append(" ");
+                String _escapedString_3 = this.escapedString(ims.getData().getRefType().getType().getName());
+                _builder.append(_escapedString_3);
+                _builder.append(" ");
+              }
+            }
+            _builder.append(" & ");
+            CharSequence _generateDocText_1 = this.generateDocText(ims.getDocu());
+            _builder.append(_generateDocText_1);
+            _builder.append("\\\\");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\\end{tabular}");
+        _builder.newLine();
+      }
+    }
+    {
+      boolean _isEmpty_1 = this._roomHelpers.getAllOutgoingMessages(pc).isEmpty();
+      boolean _not_1 = (!_isEmpty_1);
+      if (_not_1) {
+        _builder.append("\\level{3}{Outgoing Messages}");
+        _builder.newLine();
+        _builder.append("\\begin{tabular}[ht]{|l|l|l|p{8cm}|}");
+        _builder.newLine();
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("Message & Data & Type & Description\\\\");
+        _builder.newLine();
+        {
+          List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+          for(final Message oms : _allOutgoingMessages) {
+            _builder.append("\\hline");
+            _builder.newLine();
+            String _escapedString_4 = this.escapedString(oms.getName());
+            _builder.append(_escapedString_4);
+            _builder.append(" & ");
+            {
+              VarDecl _data_2 = oms.getData();
+              boolean _notEquals_2 = (!Objects.equal(_data_2, null));
+              if (_notEquals_2) {
+                _builder.append(" ");
+                String _escapedString_5 = this.escapedString(oms.getData().getName());
+                _builder.append(_escapedString_5);
+                _builder.append(" ");
+              }
+            }
+            _builder.append(" & ");
+            {
+              VarDecl _data_3 = oms.getData();
+              boolean _notEquals_3 = (!Objects.equal(_data_3, null));
+              if (_notEquals_3) {
+                _builder.append(" ");
+                String _escapedString_6 = this.escapedString(oms.getData().getRefType().getType().getName());
+                _builder.append(_escapedString_6);
+                _builder.append(" ");
+              }
+            }
+            _builder.append(" & ");
+            CharSequence _generateDocText_2 = this.generateDocText(oms.getDocu());
+            _builder.append(_generateDocText_2);
+            _builder.append("\\\\");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\\end{tabular}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence _generateDoc(final CompoundProtocolClass pc, final DocGen.DocGenContext ctx) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\level{2} {");
+    String _escapedString = this.escapedString(pc.getName());
+    _builder.append(_escapedString);
+    _builder.append("}");
+    _builder.newLineIfNotEmpty();
+    CharSequence _generateDocText = this.generateDocText(pc.getDocu());
+    _builder.append(_generateDocText);
+    _builder.newLineIfNotEmpty();
+    _builder.append("\\level{3}{Sub Protocols}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("\\begin{tabular}[ht]{|l|l|}");
+    _builder.newLine();
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\textbf{Name} & \\textbf{Protocol}\\\\");
+    _builder.newLine();
+    {
+      EList<SubProtocol> _subProtocols = pc.getSubProtocols();
+      for(final SubProtocol sub : _subProtocols) {
+        _builder.append("\\hline");
+        _builder.newLine();
+        String _escapedString_1 = this.escapedString(sub.getName());
+        _builder.append(_escapedString_1);
+        _builder.append(" & ");
+        String _escapedString_2 = this.escapedString(sub.getProtocol().getName());
+        _builder.append(_escapedString_2);
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\end{tabular}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence _generateDoc(final ActorClass ac, final DocGen.DocGenContext ctx) {
+    CharSequence _xblockexpression = null;
+    {
+      String _name = ac.getName();
+      final String filename = (_name + "_structure.jpg");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\level{2}{");
+      String _escapedString = this.escapedString(ac.getName());
+      _builder.append(_escapedString);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      CharSequence _generateDocText = this.generateDocText(ac.getDocu());
+      _builder.append(_generateDocText);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if ((this.fileExists(ctx.model, this.getImagePath(filename)).equals("true") && ((!this._roomHelpers.getAllInterfaceItems(ac).isEmpty()) || (!ac.getActorRefs().isEmpty())))) {
+          _builder.append("\\level{3}{Structure}");
+          _builder.newLine();
+          CharSequence _generateDocText_1 = this.generateDocText(ac.getStructureDocu());
+          _builder.append(_generateDocText_1);
+          _builder.newLineIfNotEmpty();
+          String _imagePath = this.getImagePath(filename);
+          String _name_1 = ac.getName();
+          String _plus = (_name_1 + " Structure");
+          CharSequence _includeGraphics = this.includeGraphics(_imagePath, this.IMGWIDTH_DEFAULT, _plus);
+          _builder.append(_includeGraphics);
+          _builder.newLineIfNotEmpty();
+        } else {
+          Documentation _structureDocu = ac.getStructureDocu();
+          boolean _notEquals = (!Objects.equal(_structureDocu, null));
+          if (_notEquals) {
+            _builder.append("\\level{3}{Structure}");
+            _builder.newLine();
+            CharSequence _generateDocText_2 = this.generateDocText(ac.getStructureDocu());
+            _builder.append(_generateDocText_2);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty = this._roomHelpers.getAllPorts(ac).isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append("\\level{3}{Ports}");
+          _builder.newLine();
+          String _generatePortDoc = this.generatePortDoc(ac);
+          _builder.append(_generatePortDoc);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isBehaviorAnnotationPresent = this._roomHelpers.isBehaviorAnnotationPresent(ac, "BehaviorManual");
+        if (_isBehaviorAnnotationPresent) {
+          _builder.append("\\level{3}{Behavior}");
+          _builder.newLine();
+          CharSequence _generateDocText_3 = this.generateDocText(ac.getBehaviorDocu());
+          _builder.append(_generateDocText_3);
+          _builder.newLineIfNotEmpty();
+          _builder.append("The behavior for ActorClass ");
+          String _name_2 = ac.getName();
+          _builder.append(_name_2);
+          _builder.append(" is implemented manually.");
+          _builder.newLineIfNotEmpty();
+        } else {
+          boolean _hasNonEmptyStateMachine = this._roomHelpers.hasNonEmptyStateMachine(ac);
+          if (_hasNonEmptyStateMachine) {
+            _builder.append("\\level{3}{Behavior}");
+            _builder.newLine();
+            CharSequence _generateDocText_4 = this.generateDocText(ac.getBehaviorDocu());
+            _builder.append(_generateDocText_4);
+            _builder.newLineIfNotEmpty();
+            CharSequence _generateFsmDoc = this.generateFsmDoc(ctx.model, ac);
+            _builder.append(_generateFsmDoc);
+            _builder.newLineIfNotEmpty();
+          } else {
+            Documentation _behaviorDocu = ac.getBehaviorDocu();
+            boolean _notEquals_1 = (!Objects.equal(_behaviorDocu, null));
+            if (_notEquals_1) {
+              _builder.append("\\level{3}{Behavior}");
+              _builder.newLine();
+              CharSequence _generateDocText_5 = this.generateDocText(ac.getBehaviorDocu());
+              _builder.append(_generateDocText_5);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_1 = ac.getAttributes().isEmpty();
+        boolean _not_1 = (!_isEmpty_1);
+        if (_not_1) {
+          _builder.append("\\level{3}{Attributes}");
+          _builder.newLine();
+          CharSequence _generateAttributesDoc = this.generateAttributesDoc(ac.getAttributes());
+          _builder.append(_generateAttributesDoc);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isEmpty_2 = ac.getOperations().isEmpty();
+        boolean _not_2 = (!_isEmpty_2);
+        if (_not_2) {
+          _builder.append("\\level{3}{Operations}");
+          _builder.newLine();
+          CharSequence _generateOperationsDoc = this.generateOperationsDoc(ac.getOperations());
+          _builder.append(_generateOperationsDoc);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateFsmDoc(final RoomModel model, final ActorClass ac) {
+    CharSequence _xblockexpression = null;
+    {
+      String _name = ac.getName();
+      final String filename = (_name + "_behavior.jpg");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\level{4}{Top Level}");
+      _builder.newLine();
+      {
+        boolean _equals = this.fileExists(model, this.getImagePath(filename)).equals("true");
+        if (_equals) {
+          String _imagePath = this.getImagePath(filename);
+          String _name_1 = ac.getName();
+          String _plus = (_name_1 + " Top State");
+          CharSequence _includeGraphics = this.includeGraphics(_imagePath, this.IMGWIDTH_DEFAULT, _plus);
+          _builder.append(_includeGraphics);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\\begin{par}");
+      _builder.newLine();
+      {
+        EList<State> _states = ac.getStateMachine().getStates();
+        for(final State s : _states) {
+          {
+            Documentation _docu = s.getDocu();
+            boolean _notEquals = (!Objects.equal(_docu, null));
+            if (_notEquals) {
+              _builder.append("\\textbf{State description} \\textit{");
+              String _replaceAll = this._codegenHelpers.getGenStatePathName(s).replaceAll("_", "\\\\_");
+              _builder.append(_replaceAll);
+              _builder.append("}:");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline");
+              _builder.newLine();
+              CharSequence _generateDocText = this.generateDocText(s.getDocu());
+              _builder.append(_generateDocText);
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline\\newline");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        EList<ChoicePoint> _chPoints = ac.getStateMachine().getChPoints();
+        for(final ChoicePoint c : _chPoints) {
+          {
+            Documentation _docu_1 = c.getDocu();
+            boolean _notEquals_1 = (!Objects.equal(_docu_1, null));
+            if (_notEquals_1) {
+              _builder.append("\\textbf{Choicepoint description} \\textit{");
+              String _escapedString = this.escapedString(c.getName());
+              _builder.append(_escapedString);
+              _builder.append("}:");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline");
+              _builder.newLine();
+              CharSequence _generateDocText_1 = this.generateDocText(c.getDocu());
+              _builder.append(_generateDocText_1);
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline\\newline");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.append("\\end{par}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        EList<State> _states_1 = ac.getStateMachine().getStates();
+        for(final State s_1 : _states_1) {
+          {
+            boolean _isLeaf = this._roomHelpers.isLeaf(s_1);
+            boolean _not = (!_isLeaf);
+            if (_not) {
+              String _generateStateDoc = this.generateStateDoc(model, ac, s_1);
+              _builder.append(_generateStateDoc);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getType(final Port p) {
+    String _xifexpression = null;
+    boolean _isConjugated = p.isConjugated();
+    if (_isConjugated) {
+      _xifexpression = "conj.";
+    } else {
+      _xifexpression = "reg.";
+    }
+    return _xifexpression;
+  }
+  
+  private String getKind(final Port p) {
+    String _xifexpression = null;
+    boolean _isInternal = this._roomHelpers.isInternal(p);
+    if (_isInternal) {
+      _xifexpression = "internal";
+    } else {
+      String _xifexpression_1 = null;
+      boolean _isExternal = this._roomHelpers.isExternal(p);
+      if (_isExternal) {
+        _xifexpression_1 = "external";
+      } else {
+        String _xifexpression_2 = null;
+        boolean _isRelay = this._roomHelpers.isRelay(p);
+        if (_isRelay) {
+          _xifexpression_2 = "relay";
+        } else {
+          _xifexpression_2 = "?";
+        }
+        _xifexpression_1 = _xifexpression_2;
+      }
+      _xifexpression = _xifexpression_1;
+    }
+    return _xifexpression;
+  }
+  
+  private String getMultAsText(final Port p) {
+    String _xifexpression = null;
+    int _multiplicity = p.getMultiplicity();
+    boolean _equals = (_multiplicity == (-1));
+    if (_equals) {
+      _xifexpression = "*";
+    } else {
+      _xifexpression = Integer.valueOf(p.getMultiplicity()).toString();
+    }
+    return _xifexpression;
+  }
+  
+  private String generatePortDoc(final ActorClass ac) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\begin{tabular}[ht]{|l|l|l|l|l|p{5cm}|}");
+    _builder.newLine();
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\textbf{Name} & \\textbf{Protocol} & \\textbf{Type} & \\textbf{Kind} & \\textbf{Multiplicity} & \\textbf{Description}\\\\");
+    _builder.newLine();
+    {
+      List<Port> _allPorts = this._roomHelpers.getAllPorts(ac);
+      for(final Port at : _allPorts) {
+        _builder.append("\\hline");
+        _builder.newLine();
+        String _escapedString = this.escapedString(at.getName());
+        _builder.append(_escapedString);
+        _builder.append(" & ");
+        String _escapedString_1 = this.escapedString(at.getProtocol().getName());
+        _builder.append(_escapedString_1);
+        _builder.append(" & ");
+        String _type = this.getType(at);
+        _builder.append(_type);
+        _builder.append(" & ");
+        String _kind = this.getKind(at);
+        _builder.append(_kind);
+        _builder.append(" & ");
+        String _multAsText = this.getMultAsText(at);
+        _builder.append(_multAsText);
+        _builder.append(" & ");
+        CharSequence _generateDocText = this.generateDocText(at.getDocu());
+        _builder.append(_generateDocText);
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.append("\\hline");
+    _builder.newLine();
+    _builder.append("\\end{tabular}");
+    _builder.newLine();
+    return _builder.toString();
+  }
+  
+  private String generateStateDoc(final RoomModel model, final ActorClass ac, final State state) {
+    String _xblockexpression = null;
+    {
+      String _name = ac.getName();
+      String _plus = (_name + "_");
+      String _genStatePathName = this._codegenHelpers.getGenStatePathName(state);
+      String _plus_1 = (_plus + _genStatePathName);
+      final String filename = (_plus_1 + "_behavior.jpg");
+      this.logger.logInfo(("Gen Filename: " + filename));
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("\\level{4}{Subgraph ");
+      String _replaceAll = this._codegenHelpers.getGenStatePathName(state).replaceAll("_", "\\\\_");
+      _builder.append(_replaceAll);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _equals = this.fileExists(model, this.getImagePath(filename)).equals("true");
+        if (_equals) {
+          String _imagePath = this.getImagePath(filename);
+          String _name_1 = ac.getName();
+          String _plus_2 = (_name_1 + "_");
+          String _genStatePathName_1 = this._codegenHelpers.getGenStatePathName(state);
+          String _plus_3 = (_plus_2 + _genStatePathName_1);
+          CharSequence _includeGraphics = this.includeGraphics(_imagePath, this.IMGWIDTH_DEFAULT, _plus_3);
+          _builder.append(_includeGraphics);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\\begin{par}");
+      _builder.newLine();
+      {
+        EList<State> _states = state.getSubgraph().getStates();
+        for(final State s : _states) {
+          {
+            Documentation _docu = s.getDocu();
+            boolean _notEquals = (!Objects.equal(_docu, null));
+            if (_notEquals) {
+              _builder.append("\\textbf{State description} \\textit{");
+              String _replaceAll_1 = this._codegenHelpers.getGenStatePathName(s).replaceAll("_", "\\\\_");
+              _builder.append(_replaceAll_1);
+              _builder.append("}:");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline");
+              _builder.newLine();
+              CharSequence _generateDocText = this.generateDocText(s.getDocu());
+              _builder.append(_generateDocText);
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline\\newline");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        EList<ChoicePoint> _chPoints = state.getSubgraph().getChPoints();
+        for(final ChoicePoint c : _chPoints) {
+          {
+            Documentation _docu_1 = c.getDocu();
+            boolean _notEquals_1 = (!Objects.equal(_docu_1, null));
+            if (_notEquals_1) {
+              _builder.append("\\textbf{Choicepoint description} \\textit{");
+              String _escapedString = this.escapedString(c.getName());
+              _builder.append(_escapedString);
+              _builder.append("}:");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline");
+              _builder.newLine();
+              CharSequence _generateDocText_1 = this.generateDocText(c.getDocu());
+              _builder.append(_generateDocText_1);
+              _builder.newLineIfNotEmpty();
+              _builder.append("\\newline\\newline");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.append("\\end{par}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        EList<State> _states_1 = state.getSubgraph().getStates();
+        for(final State s_1 : _states_1) {
+          {
+            boolean _isLeaf = this._roomHelpers.isLeaf(s_1);
+            boolean _not = (!_isLeaf);
+            if (_not) {
+              String _generateStateDoc = this.generateStateDoc(model, ac, s_1);
+              _builder.append(_generateStateDoc);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence generateAttributesDoc(final List<Attribute> attributes) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _isEmpty = attributes.isEmpty();
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        _builder.append("\\begin{tabular}[ht]{|l|l|p{8cm}|}");
+        _builder.newLine();
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\\textbf{Name} & \\textbf{Type} & \\textbf{Description}\\\\");
+        _builder.newLine();
+        {
+          for(final Attribute at : attributes) {
+            _builder.append("\\hline");
+            _builder.newLine();
+            String _escapedString = this.escapedString(at.getName());
+            _builder.append(_escapedString);
+            _builder.append(" & ");
+            String _escapedString_1 = this.escapedString(at.getType().getType().getName());
+            _builder.append(_escapedString_1);
+            _builder.append(" & ");
+            CharSequence _generateDocText = this.generateDocText(at.getDocu());
+            _builder.append(_generateDocText);
+            _builder.append("\\\\");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\\end{tabular}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence generateOperationsDoc(final List<StandardOperation> operations) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      for(final StandardOperation op : operations) {
+        _builder.append("\\begin{tabular}[ht]{|l|l|}");
+        _builder.newLine();
+        _builder.append("\\hline\t\t");
+        _builder.newLine();
+        _builder.append("\t");
+        _builder.append("Name: & ");
+        String _escapedString = this.escapedString(op.getName());
+        _builder.append(_escapedString, "\t");
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\t");
+        _builder.append("ReturnType: &  ");
+        {
+          RefableType _returnType = op.getReturnType();
+          boolean _notEquals = (!Objects.equal(_returnType, null));
+          if (_notEquals) {
+            String _escapedString_1 = this.escapedString(op.getReturnType().getType().getName());
+            _builder.append(_escapedString_1, "\t");
+          } else {
+            _builder.append("void");
+          }
+        }
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\t");
+        _builder.append("Arguments: & ");
+        {
+          EList<VarDecl> _arguments = op.getArguments();
+          boolean _hasElements = false;
+          for(final VarDecl pa : _arguments) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(", ", "\t");
+            }
+            String _escapedString_2 = this.escapedString(pa.getName());
+            _builder.append(_escapedString_2, "\t");
+            _builder.append(":");
+            String _escapedString_3 = this.escapedString(pa.getRefType().getType().getName());
+            _builder.append(_escapedString_3, "\t");
+          }
+        }
+        _builder.append("\\\\");
+        _builder.newLineIfNotEmpty();
+        {
+          Documentation _docu = op.getDocu();
+          boolean _notEquals_1 = (!Objects.equal(_docu, null));
+          if (_notEquals_1) {
+            _builder.append("\t");
+            _builder.append("\\hline");
+            _builder.newLine();
+            {
+              int _length = op.getDocu().toString().length();
+              boolean _greaterThan = (_length > 85);
+              if (_greaterThan) {
+                _builder.append("\t");
+                _builder.append("\\multicolumn{2} {|p{13cm}|} {");
+                CharSequence _generateDocText = this.generateDocText(op.getDocu());
+                _builder.append(_generateDocText, "\t");
+                _builder.append("}\\\\");
+                _builder.newLineIfNotEmpty();
+              } else {
+                _builder.append("\t");
+                _builder.append("\\multicolumn{2} {|l|} {");
+                CharSequence _generateDocText_1 = this.generateDocText(op.getDocu());
+                _builder.append(_generateDocText_1, "\t");
+                _builder.append("}\\\\");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+          }
+        }
+        _builder.append("\t");
+        _builder.append("\\hline");
+        _builder.newLine();
+        _builder.append("\\end{tabular}");
+        _builder.newLine();
+        _builder.append("\\newline\\newline\\newline");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence generateDocText(final Documentation doc) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _notEquals = (!Objects.equal(doc, null));
+      if (_notEquals) {
+        _builder.append("% begin text from user Documentation");
+        _builder.newLine();
+        {
+          EList<String> _lines = doc.getLines();
+          for(final String line : _lines) {
+            String _escapedString = this.escapedString(line);
+            _builder.append(_escapedString);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _builder.append("% end text from user Documentation");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  private String fileExists(final RoomModel model, final String f) {
+    String _docGenerationTargetPath = this.roomExt.getDocGenerationTargetPath(model);
+    final String absPath = (_docGenerationTargetPath + f);
+    final File file = new File(absPath);
+    final boolean exist = file.exists();
+    if ((exist == true)) {
+      this.logger.logInfo(("File found ! " + f));
+      return "true";
+    } else {
+      this.logger.logInfo(("File not found ! " + f));
+      return "false";
+    }
+  }
+  
+  private CharSequence includeGraphics(final String filename, final String width, final String caption) {
+    CharSequence _xblockexpression = null;
+    {
+      String latexCaption = caption.replaceAll("_", "\\\\_");
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("{");
+      _builder.newLine();
+      _builder.append("\\centering{}");
+      _builder.newLine();
+      _builder.append("\\includegraphics[width=");
+      _builder.append(width);
+      _builder.append("]{");
+      _builder.append(filename);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\\figcaption{");
+      _builder.append(latexCaption);
+      _builder.append("}");
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String escapedString(final String text) {
+    return text.replace("_", "\\_");
+  }
+  
+  private String getImagePath(final String filename) {
+    String filenamei = ((this.IMGDIR_DEFAULT + "/") + filename);
+    filenamei = filenamei.replaceAll("\\\\", "/");
+    return filenamei;
+  }
+  
+  private void saveAs(final CharSequence content, final String filename) {
+    this.fileAccess.generateFile(filename, content);
+  }
+  
+  private String docFragmentName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".tex");
+  }
+  
+  private CharSequence generateImport(final RoomClass rc, final String dir) {
+    StringConcatenation _builder = new StringConcatenation();
+    CharSequence _generateImport = this.generateImport(this.docFragmentName(rc), dir);
+    _builder.append(_generateImport);
+    return _builder;
+  }
+  
+  private CharSequence generateImport(final String name, final String dir) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\\subimport*{");
+    _builder.append(dir);
+    _builder.append("/}{");
+    _builder.append(name);
+    _builder.append("}");
+    return _builder;
+  }
+  
+  private CharSequence generateDoc(final RoomClass ac, final DocGen.DocGenContext ctx) {
+    if (ac instanceof ActorClass) {
+      return _generateDoc((ActorClass)ac, ctx);
+    } else if (ac instanceof DataClass) {
+      return _generateDoc((DataClass)ac, ctx);
+    } else if (ac instanceof SubSystemClass) {
+      return _generateDoc((SubSystemClass)ac, ctx);
+    } else if (ac instanceof CompoundProtocolClass) {
+      return _generateDoc((CompoundProtocolClass)ac, ctx);
+    } else if (ac instanceof EnumerationType) {
+      return _generateDoc((EnumerationType)ac, ctx);
+    } else if (ac instanceof LogicalSystem) {
+      return _generateDoc((LogicalSystem)ac, ctx);
+    } else if (ac instanceof ProtocolClass) {
+      return _generateDoc((ProtocolClass)ac, ctx);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(ac, ctx).toString());
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.java b/plugins/org.eclipse.etrice.generator.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.java
new file mode 100644
index 000000000..3e3c6592b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.doc/xtend-gen/org/eclipse/etrice/generator/doc/gen/InstanceDiagramGen.java
@@ -0,0 +1,259 @@
+/**
+ * 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.generator.doc.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.File;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.etmap.util.ETMapUtil;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+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.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.ILogger;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+@Singleton
+@SuppressWarnings("all")
+public class InstanceDiagramGen {
+  @Inject
+  @Extension
+  private JavaIoFileSystemAccess fileAccess;
+  
+  @Inject
+  @Extension
+  private RoomExtensions roomExt;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    EList<RoomModel> _models = root.getModels();
+    for (final RoomModel model : _models) {
+      {
+        String _docGenerationTargetPath = this.roomExt.getDocGenerationTargetPath(model);
+        String path = (_docGenerationTargetPath + "/images");
+        this.fileAccess.setOutputPath(path);
+        String batchFile = "dot2jpg.bat";
+        EList<SystemInstance> _systemInstances = root.getSystemInstances();
+        for (final SystemInstance sys : _systemInstances) {
+          {
+            String _name = sys.getName();
+            String file = (_name + "_instanceTree.dot");
+            this.logger.logInfo((((("generating instance tree diagram: \'" + file) + "\' in \'") + path) + "\'"));
+            this.fileAccess.generateFile(file, this.generate(root, sys));
+          }
+        }
+        this.fileAccess.generateFile(batchFile, this.generate2jpg(root));
+        this.runDot2Jpg(path, batchFile);
+      }
+    }
+  }
+  
+  private CharSequence generate2jpg(final Root root) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      EList<SystemInstance> _systemInstances = root.getSystemInstances();
+      for(final SystemInstance sys : _systemInstances) {
+        _builder.append("dot -Tjpg -o ");
+        String _name = sys.getName();
+        _builder.append(_name);
+        _builder.append("_instanceTree.jpg ");
+        String _name_1 = sys.getName();
+        _builder.append(_name_1);
+        _builder.append("_instanceTree.dot");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence generate(final Root root, final SystemInstance sys) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("digraph ");
+    String _name = sys.getName();
+    _builder.append(_name);
+    _builder.append(" {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("rankdir=LR;");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("node [shape=box];");
+    _builder.newLine();
+    _builder.append("\t");
+    String _pathName = this.roomExt.getPathName(sys.getPath());
+    _builder.append(_pathName, "\t");
+    _builder.append(" [label=\"");
+    String _name_1 = sys.getName();
+    _builder.append(_name_1, "\t");
+    _builder.append("\\n(");
+    String _name_2 = sys.getName();
+    _builder.append(_name_2, "\t");
+    _builder.append(")\" style=filled color=red];");
+    _builder.newLineIfNotEmpty();
+    {
+      EList<SubSystemInstance> _instances = sys.getInstances();
+      for(final SubSystemInstance ssi : _instances) {
+        _builder.append("\t");
+        String _pathName_1 = this.roomExt.getPathName(ssi.getPath());
+        _builder.append(_pathName_1, "\t");
+        _builder.append(" [label=\"");
+        String _name_3 = ssi.getName();
+        _builder.append(_name_3, "\t");
+        _builder.append("\\n(");
+        String _name_4 = ssi.getSubSystemClass().getName();
+        _builder.append(_name_4, "\t");
+        _builder.append(")\" style=filled color=yellow];");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        String _pathName_2 = this.roomExt.getPathName(sys.getPath());
+        _builder.append(_pathName_2, "\t");
+        _builder.append(" -> ");
+        String _pathName_3 = this.roomExt.getPathName(ssi.getPath());
+        _builder.append(_pathName_3, "\t");
+        _builder.append(";  ");
+        _builder.newLineIfNotEmpty();
+        {
+          EList<AbstractInstance> _instances_1 = ssi.getInstances();
+          for(final AbstractInstance ai : _instances_1) {
+            _builder.append("\t");
+            String _instance = this.instance(ai);
+            _builder.append(_instance, "\t");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private String instance(final AbstractInstance ai) {
+    String _xblockexpression = null;
+    {
+      EObject _eContainer = ai.eContainer();
+      final StructureInstance parent = ((StructureInstance) _eContainer);
+      final ETMapUtil.MappedThread pthread = ETMapUtil.getMappedThread(ai);
+      String _xifexpression = null;
+      boolean _equals = Objects.equal(pthread, null);
+      if (_equals) {
+        _xifexpression = "?";
+      } else {
+        _xifexpression = pthread.getThread().getName();
+      }
+      final String tname = _xifexpression;
+      final NodeRef node = ETMapUtil.getNodeRef(ai);
+      String _xifexpression_1 = null;
+      boolean _equals_1 = Objects.equal(node, null);
+      if (_equals_1) {
+        _xifexpression_1 = "?";
+      } else {
+        _xifexpression_1 = node.getName();
+      }
+      final String nname = _xifexpression_1;
+      String _xifexpression_2 = null;
+      if ((ai instanceof ActorInterfaceInstance)) {
+        _xifexpression_2 = "optional ";
+      } else {
+        _xifexpression_2 = "";
+      }
+      final String optional = _xifexpression_2;
+      String _xifexpression_3 = null;
+      if ((ai instanceof ActorInstance)) {
+        _xifexpression_3 = ((ActorInstance) ai).getActorClass().getName();
+      } else {
+        String _xifexpression_4 = null;
+        if ((ai instanceof ActorInterfaceInstance)) {
+          _xifexpression_4 = ((ActorInterfaceInstance) ai).getActorClass().getName();
+        } else {
+          _xifexpression_4 = "?";
+        }
+        _xifexpression_3 = _xifexpression_4;
+      }
+      final String clsname = _xifexpression_3;
+      StringConcatenation _builder = new StringConcatenation();
+      String _pathName = this.roomExt.getPathName(ai.getPath());
+      _builder.append(_pathName);
+      _builder.append(" [label=\"");
+      _builder.append(optional);
+      String _name = ai.getName();
+      _builder.append(_name);
+      _builder.append("\\n(");
+      _builder.append(clsname);
+      _builder.append(")\\n@");
+      _builder.append(nname);
+      _builder.append(":");
+      _builder.append(tname);
+      _builder.append("\"");
+      {
+        boolean _isEmpty = optional.isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _builder.append(" color=blue style=dashed");
+        }
+      }
+      _builder.append("];");
+      _builder.newLineIfNotEmpty();
+      String _pathName_1 = this.roomExt.getPathName(parent.getPath());
+      _builder.append(_pathName_1);
+      _builder.append(" -> ");
+      String _pathName_2 = this.roomExt.getPathName(ai.getPath());
+      _builder.append(_pathName_2);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      {
+        if ((ai instanceof StructureInstance)) {
+          {
+            EList<AbstractInstance> _instances = ((StructureInstance) ai).getInstances();
+            for(final AbstractInstance sub_ai : _instances) {
+              String _instance = this.instance(sub_ai);
+              _builder.append(_instance);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  private void runDot2Jpg(final String path, final String bat) {
+    File wdir = new File(path);
+    try {
+      final Process p = Runtime.getRuntime().exec(("cmd /C " + bat), null, wdir);
+      int _waitFor = p.waitFor();
+      String _plus = ((bat + " finished with ") + Integer.valueOf(_waitFor));
+      this.logger.logInfo(_plus);
+    } catch (final Throwable _t) {
+      if (_t instanceof Exception) {
+        final Exception e = (Exception)_t;
+        e.printStackTrace();
+      } else {
+        throw Exceptions.sneakyThrow(_t);
+      }
+    }
+  }
+}
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..48311b750 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
@@ -19,7 +19,7 @@ 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;
 
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/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 c291ab61b..796f7e1b6 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..64609294c 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,232 @@
 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
+	@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?
+		var offset = 2 + if (omitBase)
+			allStateNodes.filter[inherited].size else 0
+		var baseStates = (if (omitBase)
+			allStateNodes.filter[!inherited] else allStateNodes).map[stateGraphNode].filter(typeof(State)).toList
+
+		baseStates = baseStates.leafStatesLast.toList
+
+		var list = <Pair<String, String>>newArrayList
+		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 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 +265,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 +285,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 +312,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 +338,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 +350,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 +393,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 +422,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 +433,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 +450,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..94f1a313c 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
     }
 
     /**
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..8ccc57d76 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,30 @@
 
 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.emf.common.util.EList;
+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 +49,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.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.java b/plugins/org.eclipse.etrice.generator.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.java
new file mode 100644
index 000000000..8bcdcfc2b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/AbstractStateMachineGenerator.java
@@ -0,0 +1,1774 @@
+/**
+ * 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.generator.fsm.generic;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType;
+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.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+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.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.etrice.generator.fsm.generic.FSMExtensions;
+import org.eclipse.etrice.generator.fsm.generic.IDetailCodeTranslator;
+import org.eclipse.etrice.generator.fsm.generic.IIfItemIdGenerator;
+import org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase;
+import org.eclipse.etrice.generator.fsm.generic.IMessageIdGenerator;
+import org.eclipse.etrice.generator.fsm.generic.TransitionChainGenerator;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.util.Tuples;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+/**
+ * @author Henrik Rentz-Reichert
+ */
+@SuppressWarnings("all")
+public abstract class AbstractStateMachineGenerator {
+  @Inject
+  @Extension
+  public FSMHelpers _fSMHelpers;
+  
+  @Inject
+  @Extension
+  public CodegenHelpers _codegenHelpers;
+  
+  @Inject
+  @Extension
+  public FSMExtensions _fSMExtensions;
+  
+  @Inject
+  public ILanguageExtensionBase langExt;
+  
+  @Inject
+  public IMessageIdGenerator msgIdGen;
+  
+  @Inject
+  public IIfItemIdGenerator itemIdGen;
+  
+  @Inject
+  public TransitionChainGenerator transitionChainGenerator;
+  
+  @Inject
+  public IDetailCodeTranslator translator;
+  
+  @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
+   */
+  public String genTriggerConstants(final GraphContainer gc) {
+    return this.genTriggerConstants(gc, this.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
+   */
+  public String genTriggerConstants(final GraphContainer gc, final boolean omitBase) {
+    List<MessageFromIf> _xifexpression = null;
+    if (omitBase) {
+      _xifexpression = this._fSMHelpers.getOwnMessagesFromInterfaces(gc.getComponent());
+    } else {
+      _xifexpression = this._fSMHelpers.getAllMessagesFromInterfaces(gc.getComponent());
+    }
+    final List<MessageFromIf> triggers = _xifexpression;
+    final ArrayList<Pair<String, String>> list = CollectionLiterals.<Pair<String, String>>newArrayList();
+    list.add(Tuples.<String, String>pair("POLLING", "0"));
+    for (final MessageFromIf mif : triggers) {
+      boolean _isEventDriven = mif.getFrom().isEventDriven();
+      if (_isEventDriven) {
+        String _triggerCodeName = this.getTriggerCodeName(mif);
+        String _ifItemId = this.itemIdGen.getIfItemId(mif.getFrom());
+        String _plus = (_ifItemId + " + EVT_SHIFT*");
+        String _messageID = this.msgIdGen.getMessageID(mif);
+        String _plus_1 = (_plus + _messageID);
+        list.add(Tuples.<String, String>pair(_triggerCodeName, _plus_1));
+      }
+    }
+    return this.langExt.genEnumeration("triggers", list);
+  }
+  
+  public String getTriggerCodeName(final MessageFromIf mif) {
+    String _name = mif.getFrom().getName();
+    String _plus = ("TRIG_" + _name);
+    String _plus_1 = (_plus + "__");
+    String _messageName = this.fsmNameProvider.getMessageName(mif.getMessage());
+    return (_plus_1 + _messageName);
+  }
+  
+  /**
+   * generates state ID constants.
+   * Inheritance (if available) is used for base class IDs.
+   * 
+   * @param gc the {@link GraphContainer}
+   * @return the generated code
+   */
+  public String genStateIdConstants(final GraphContainer gc) {
+    return this.genStateIdConstants(gc, this.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
+   */
+  public String genStateIdConstants(final GraphContainer gc, final boolean omitBase) {
+    final List<Node> allStateNodes = IteratorExtensions.<Node>toList(FsmGenExtensions.getAllStateNodes(gc.getGraph()));
+    int _xifexpression = (int) 0;
+    if (omitBase) {
+      final Function1<Node, Boolean> _function = (Node it) -> {
+        return Boolean.valueOf(it.isInherited());
+      };
+      _xifexpression = IterableExtensions.size(IterableExtensions.<Node>filter(allStateNodes, _function));
+    } else {
+      _xifexpression = 0;
+    }
+    int offset = (2 + _xifexpression);
+    Iterable<Node> _xifexpression_1 = null;
+    if (omitBase) {
+      final Function1<Node, Boolean> _function_1 = (Node it) -> {
+        boolean _isInherited = it.isInherited();
+        return Boolean.valueOf((!_isInherited));
+      };
+      _xifexpression_1 = IterableExtensions.<Node>filter(allStateNodes, _function_1);
+    } else {
+      _xifexpression_1 = allStateNodes;
+    }
+    final Function1<Node, StateGraphNode> _function_2 = (Node it) -> {
+      return it.getStateGraphNode();
+    };
+    List<State> baseStates = IterableExtensions.<State>toList(Iterables.<State>filter(IterableExtensions.<Node, StateGraphNode>map(_xifexpression_1, _function_2), State.class));
+    baseStates = IterableExtensions.<State>toList(this._fSMExtensions.getLeafStatesLast(baseStates));
+    ArrayList<Pair<String, String>> list = CollectionLiterals.<Pair<String, String>>newArrayList();
+    if ((!omitBase)) {
+      list.add(Tuples.<String, String>pair("NO_STATE", "0"));
+      list.add(Tuples.<String, String>pair("STATE_TOP", "1"));
+    }
+    for (final State state : baseStates) {
+      {
+        list.add(Tuples.<String, String>pair(this._codegenHelpers.getGenStateId(state), Integer.valueOf(offset).toString()));
+        offset = (offset + 1);
+      }
+    }
+    list.add(Tuples.<String, String>pair("STATE_MAX", Integer.valueOf(offset).toString()));
+    return this.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
+   */
+  public String genTransitionChainConstants(final GraphContainer gc) {
+    return this.genTransitionChainConstants(gc, false);
+  }
+  
+  /**
+   * 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
+   */
+  public String genTransitionChainConstants(final GraphContainer gc, final boolean omitBase) {
+    Iterator<Link> _xifexpression = null;
+    if (omitBase) {
+      final Function1<Link, Boolean> _function = (Link it) -> {
+        boolean _isInherited = it.isInherited();
+        return Boolean.valueOf((!_isInherited));
+      };
+      _xifexpression = IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(gc.getGraph()), _function);
+    } else {
+      _xifexpression = FsmGenExtensions.getAllLinks(gc.getGraph());
+    }
+    final Function1<Link, TransitionBase> _function_1 = (Link it) -> {
+      return it.getTransition();
+    };
+    final Function1<TransitionBase, Boolean> _function_2 = (TransitionBase it) -> {
+      return Boolean.valueOf(FsmGenExtensions.isChainHead(it));
+    };
+    final List<Transition> chains = IteratorExtensions.<Transition>toList(Iterators.<Transition>filter(IteratorExtensions.<TransitionBase>filter(IteratorExtensions.<Link, TransitionBase>map(_xifexpression, _function_1), _function_2), Transition.class));
+    int _xifexpression_1 = (int) 0;
+    if (omitBase) {
+      final Function1<Link, Boolean> _function_3 = (Link it) -> {
+        return Boolean.valueOf(it.isInherited());
+      };
+      _xifexpression_1 = IteratorExtensions.size(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(gc.getGraph()), _function_3));
+    } else {
+      _xifexpression_1 = 0;
+    }
+    int offset = _xifexpression_1;
+    ArrayList<Pair<String, String>> list = CollectionLiterals.<Pair<String, String>>newArrayList();
+    for (final Transition chain : chains) {
+      {
+        offset = (offset + 1);
+        list.add(Tuples.<String, String>pair(this._codegenHelpers.getGenChainId(chain), Integer.valueOf(offset).toString()));
+      }
+    }
+    return this.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
+   */
+  public String genEntryAndExitCodes(final GraphContainer gc, final boolean generateImplementation) {
+    return this.genEntryAndExitCodes(gc, generateImplementation, this.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
+   */
+  public String genEntryAndExitCodes(final GraphContainer gc, final boolean generateImplementation, final boolean omitBase) {
+    String _xblockexpression = null;
+    {
+      final Function1<Node, Boolean> _function = (Node it) -> {
+        return Boolean.valueOf(((!omitBase) || (!it.isInherited())));
+      };
+      final List<Node> states = IteratorExtensions.<Node>toList(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(gc.getGraph()), _function));
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        for(final Node state : states) {
+          String _genActionCodeMethods = this.genActionCodeMethods(gc, state, generateImplementation);
+          _builder.append(_genActionCodeMethods);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * 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
+   */
+  public String genActionCodes(final GraphContainer gc, final boolean generateImplementation) {
+    return this.genActionCodes(gc, generateImplementation, this.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
+   */
+  public String genActionCodes(final GraphContainer gc, final boolean generateImplementation, final boolean omitBase) {
+    String _xblockexpression = null;
+    {
+      final Function1<Link, Boolean> _function = (Link it) -> {
+        return Boolean.valueOf(((!omitBase) || (!it.isInherited())));
+      };
+      final Function1<Link, Boolean> _function_1 = (Link it) -> {
+        return Boolean.valueOf(this._fSMHelpers.hasDetailCode(it.getTransition().getAction()));
+      };
+      final List<Link> transitions = IteratorExtensions.<Link>toList(IteratorExtensions.<Link>filter(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(gc.getGraph()), _function), _function_1));
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        for(final Link tr : transitions) {
+          String _genActionCodeMethod = this.genActionCodeMethod(gc, tr, generateImplementation);
+          _builder.append(_genActionCodeMethod);
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  public String genStateSwitchMethods(final GraphContainer gc, final boolean generateImplementation) {
+    String _xblockexpression = null;
+    {
+      final ModelComponent mc = gc.getComponent();
+      ComponentCommunicationType _commType = mc.getCommType();
+      final boolean async = Objects.equal(_commType, ComponentCommunicationType.ASYNCHRONOUS);
+      ComponentCommunicationType _commType_1 = mc.getCommType();
+      final boolean eventDriven = Objects.equal(_commType_1, ComponentCommunicationType.EVENT_DRIVEN);
+      String _interfaceItemType = this.interfaceItemType();
+      String _pointerLiteral = this.langExt.pointerLiteral();
+      final String ifItemPtr = (_interfaceItemType + _pointerLiteral);
+      final boolean handleEvents = (async || eventDriven);
+      String _xifexpression = null;
+      boolean _usesInheritance = this.langExt.usesInheritance();
+      if (_usesInheritance) {
+        String _className = this.getClassName(mc);
+        String _scopeSeparator = this.langExt.scopeSeparator();
+        _xifexpression = (_className + _scopeSeparator);
+      } else {
+        _xifexpression = "";
+      }
+      final String chainIDScope = _xifexpression;
+      final String opScope = this.langExt.operationScope(this.getClassName(mc), (!generateImplementation));
+      String _xifexpression_1 = null;
+      boolean _usesInheritance_1 = this.langExt.usesInheritance();
+      if (_usesInheritance_1) {
+        _xifexpression_1 = opScope;
+      } else {
+        _xifexpression_1 = "";
+      }
+      final String opScopePriv = _xifexpression_1;
+      String _xifexpression_2 = null;
+      boolean _usesInheritance_2 = this.langExt.usesInheritance();
+      if (_usesInheritance_2) {
+        _xifexpression_2 = this.langExt.accessLevelPublic();
+      } else {
+        _xifexpression_2 = this.langExt.accessLevelPrivate();
+      }
+      final String publicIf = _xifexpression_2;
+      final String privAccess = this.langExt.accessLevelPrivate();
+      final String selfPtr = this.langExt.selfPointer(this.getClassName(mc), true);
+      final String selfOnly = this.langExt.selfPointer(this.getClassName(mc), false);
+      String _xifexpression_3 = null;
+      boolean _usesInheritance_3 = this.langExt.usesInheritance();
+      if (_usesInheritance_3) {
+        String _xifexpression_4 = null;
+        boolean _usesPointers = this.langExt.usesPointers();
+        if (_usesPointers) {
+          _xifexpression_4 = "->getLocalId()";
+        } else {
+          _xifexpression_4 = ".getLocalId()";
+        }
+        _xifexpression_3 = _xifexpression_4;
+      } else {
+        _xifexpression_3 = "->localId";
+      }
+      final String getLocalId = _xifexpression_3;
+      String _xifexpression_5 = null;
+      boolean _usesPointers_1 = this.langExt.usesPointers();
+      if (_usesPointers_1) {
+        _xifexpression_5 = ("const " + ifItemPtr);
+      } else {
+        _xifexpression_5 = ifItemPtr;
+      }
+      final String constIfItemPtr = _xifexpression_5;
+      final boolean usesHdlr = this.usesHandlerTrPoints(gc);
+      final Function1<Node, String> _function = (Node it) -> {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return this._codegenHelpers.getGenStateId(((State) _stateGraphNode));
+      };
+      final List<Node> nodes = IterableExtensions.<Node, String>sortBy(IteratorExtensions.<Node>toList(FsmGenExtensions.getAllStateNodes(gc.getGraph())), _function);
+      final HashMap<State, Node> state2node = CollectionLiterals.<State, Node>newHashMap();
+      final Consumer<Node> _function_1 = (Node it) -> {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        state2node.put(((State) _stateGraphNode), it);
+      };
+      nodes.forEach(_function_1);
+      final Function1<Node, StateGraphNode> _function_2 = (Node it) -> {
+        return it.getStateGraphNode();
+      };
+      final List<State> states = IterableExtensions.<State>toList(Iterables.<State>filter(ListExtensions.<Node, StateGraphNode>map(nodes, _function_2), State.class));
+      final Function1<Link, Boolean> _function_3 = (Link it) -> {
+        return Boolean.valueOf(FsmGenExtensions.isChainHead(it));
+      };
+      final Function1<Link, String> _function_4 = (Link it) -> {
+        return this._codegenHelpers.getGenChainId(it.getTransition());
+      };
+      final List<Link> transitionChains = IterableExtensions.<Link, String>sortBy(IteratorExtensions.<Link>toList(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(gc.getGraph()), _function_3)), _function_4);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* calls exit codes while exiting from the current state to one of its");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* parent states while remembering the history");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @param current__et - the current state");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @param to - the final parent state");
+      _builder.newLine();
+      {
+        if (usesHdlr) {
+          _builder.append("* @param handler__et - entry and exit codes are called only if not handler (for handler TransitionPoints)");
+          _builder.newLine();
+        }
+      }
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      {
+        if (generateImplementation) {
+          _builder.append(privAccess);
+          _builder.append("void ");
+          _builder.append(opScopePriv);
+          _builder.append("exitTo(");
+          _builder.append(selfPtr);
+          String _stateType = this.stateType();
+          _builder.append(_stateType);
+          _builder.append(" current__et, ");
+          String _stateType_1 = this.stateType();
+          _builder.append(_stateType_1);
+          _builder.append(" to");
+          {
+            if (usesHdlr) {
+              _builder.append(", ");
+              String _boolType = this.boolType();
+              _builder.append(_boolType);
+              _builder.append(" handler__et");
+            }
+          }
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("while (current__et!=to) {");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("switch (current__et) {");
+          _builder.newLine();
+          {
+            for(final State state : states) {
+              _builder.append("\t\t\t");
+              _builder.append("case ");
+              String _genStateId = this._codegenHelpers.getGenStateId(state);
+              _builder.append(_genStateId, "\t\t\t");
+              _builder.append(":");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              {
+                boolean _hasExitCode = this._fSMHelpers.hasExitCode(state, true);
+                if (_hasExitCode) {
+                  {
+                    if (usesHdlr) {
+                      _builder.append("if (!handler__et) ");
+                    }
+                  }
+                  String _exitCodeOperationName = this._codegenHelpers.getExitCodeOperationName(state);
+                  _builder.append(_exitCodeOperationName, "\t\t\t\t");
+                  _builder.append("(");
+                  String _selfPointer = this.langExt.selfPointer(false);
+                  _builder.append(_selfPointer, "\t\t\t\t");
+                  _builder.append(");");
+                }
+              }
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              String _setHistory = this.setHistory(this._codegenHelpers.getParentStateId(state), this._codegenHelpers.getGenStateId(state));
+              _builder.append(_setHistory, "\t\t\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("current__et = ");
+              String _parentStateId = this._codegenHelpers.getParentStateId(state);
+              _builder.append(_parentStateId, "\t\t\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("break;");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t\t\t");
+          _builder.append("default:");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("/* should not occur */");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        } else {
+          _builder.append("void exitTo(");
+          _builder.append(selfPtr);
+          String _stateType_2 = this.stateType();
+          _builder.append(_stateType_2);
+          _builder.append(" current__et, ");
+          String _stateType_3 = this.stateType();
+          _builder.append(_stateType_3);
+          _builder.append(" to");
+          {
+            if (usesHdlr) {
+              _builder.append(", ");
+              String _boolType_1 = this.boolType();
+              _builder.append(_boolType_1);
+              _builder.append(" handler__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* calls action, entry and exit codes along a transition chain. The generic data are cast to typed data");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* matching the trigger of this chain. The ID of the final state is returned");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @param chain__et - the chain ID");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @param generic_data__et - the generic data pointer");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @return the +/- ID of the final state either with a positive sign, that indicates to execute the state\'s entry code, or a negative sign vice versa");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      {
+        if (generateImplementation) {
+          _builder.append(privAccess);
+          String _stateType_4 = this.stateType();
+          _builder.append(_stateType_4);
+          _builder.append(" ");
+          _builder.append(opScopePriv);
+          _builder.append("executeTransitionChain(");
+          _builder.append(selfPtr);
+          _builder.append("int chain__et");
+          {
+            if (handleEvents) {
+              _builder.append(", ");
+              _builder.append(constIfItemPtr);
+              _builder.append(" ifitem, ");
+              String _voidPointer = this.langExt.voidPointer();
+              _builder.append(_voidPointer);
+              _builder.append(" generic_data__et");
+            }
+          }
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("switch (chain__et) {");
+          _builder.newLine();
+          {
+            for(final Link tc : transitionChains) {
+              _builder.append("\t\t");
+              _builder.append("case ");
+              _builder.append(chainIDScope, "\t\t");
+              String _genChainId = this._codegenHelpers.getGenChainId(tc.getTransition());
+              _builder.append(_genChainId, "\t\t");
+              _builder.append(":");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("{");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              String _generateExecuteChain = this.transitionChainGenerator.generateExecuteChain(gc, tc);
+              _builder.append(_generateExecuteChain, "\t\t\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t\t\t");
+          _builder.append("default:");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("/* should not occur */");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("return NO_STATE;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        } else {
+          String _stateType_5 = this.stateType();
+          _builder.append(_stateType_5);
+          _builder.append(" executeTransitionChain(");
+          _builder.append(selfPtr);
+          _builder.append("int chain__et");
+          {
+            if (handleEvents) {
+              _builder.append(", ");
+              _builder.append(constIfItemPtr);
+              _builder.append(" ifitem, ");
+              String _voidPointer_1 = this.langExt.voidPointer();
+              _builder.append(_voidPointer_1);
+              _builder.append(" generic_data__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/**");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* calls entry codes while entering a state\'s history. The ID of the final leaf state is returned");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("* @param state__et - the state which is entered");
+      _builder.newLine();
+      {
+        if (usesHdlr) {
+          _builder.append("* @param handler__et - entry code is executed if not handler");
+          _builder.newLine();
+        }
+      }
+      _builder.append(" ");
+      _builder.append("* @return - the ID of the final leaf state");
+      _builder.newLine();
+      _builder.append(" ");
+      _builder.append("*/");
+      _builder.newLine();
+      {
+        if (generateImplementation) {
+          _builder.append(privAccess);
+          String _stateType_6 = this.stateType();
+          _builder.append(_stateType_6);
+          _builder.append(" ");
+          _builder.append(opScopePriv);
+          _builder.append("enterHistory(");
+          _builder.append(selfPtr);
+          String _stateType_7 = this.stateType();
+          _builder.append(_stateType_7);
+          _builder.append(" state__et");
+          {
+            if (usesHdlr) {
+              _builder.append(", ");
+              String _boolType_2 = this.boolType();
+              _builder.append(_boolType_2);
+              _builder.append(" handler__et");
+            }
+          }
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          final Function1<State, Boolean> _function_5 = (State s) -> {
+            return Boolean.valueOf(this._fSMHelpers.hasEntryCode(s, true));
+          };
+          boolean _isEmpty = IterableExtensions.isEmpty(IterableExtensions.<State>filter(states, _function_5));
+          final boolean needsSkipVar = (!_isEmpty);
+          _builder.newLineIfNotEmpty();
+          {
+            if (needsSkipVar) {
+              _builder.append("\t");
+              String _boolType_3 = this.boolType();
+              _builder.append(_boolType_3, "\t");
+              _builder.append(" skip_entry__et = ");
+              String _booleanConstant = this.langExt.booleanConstant(false);
+              _builder.append(_booleanConstant, "\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("if (state__et >= STATE_MAX) {");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("state__et = ");
+          {
+            boolean _usesInheritance_4 = this.langExt.usesInheritance();
+            boolean _not = (!_usesInheritance_4);
+            if (_not) {
+              _builder.append("(");
+              String _stateType_8 = this.stateType();
+              _builder.append(_stateType_8, "\t\t");
+              _builder.append(")");
+            }
+          }
+          _builder.append(" (state__et - STATE_MAX);");
+          _builder.newLineIfNotEmpty();
+          {
+            if (needsSkipVar) {
+              _builder.append("\t\t");
+              _builder.append("skip_entry__et = ");
+              String _booleanConstant_1 = this.langExt.booleanConstant(true);
+              _builder.append(_booleanConstant_1, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("while (");
+          String _booleanConstant_2 = this.langExt.booleanConstant(true);
+          _builder.append(_booleanConstant_2, "\t");
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("switch (state__et) {");
+          _builder.newLine();
+          {
+            for(final State state_1 : states) {
+              _builder.append("\t\t\t");
+              _builder.append("case ");
+              String _genStateId_1 = this._codegenHelpers.getGenStateId(state_1);
+              _builder.append(_genStateId_1, "\t\t\t");
+              _builder.append(":");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              {
+                boolean _hasEntryCode = this._fSMHelpers.hasEntryCode(state_1, true);
+                if (_hasEntryCode) {
+                  _builder.append("if (!(skip_entry__et");
+                  {
+                    if (usesHdlr) {
+                      _builder.append(" || handler__et");
+                    }
+                  }
+                  _builder.append(")) ");
+                  String _entryCodeOperationName = this._codegenHelpers.getEntryCodeOperationName(state_1);
+                  _builder.append(_entryCodeOperationName, "\t\t\t\t");
+                  _builder.append("(");
+                  String _selfPointer_1 = this.langExt.selfPointer(false);
+                  _builder.append(_selfPointer_1, "\t\t\t\t");
+                  _builder.append(");");
+                }
+              }
+              _builder.newLineIfNotEmpty();
+              {
+                boolean _isLeaf = this._fSMHelpers.isLeaf(state_1);
+                if (_isLeaf) {
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("/* in leaf state: return state id */");
+                  _builder.newLine();
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("return ");
+                  String _genStateId_2 = this._codegenHelpers.getGenStateId(state_1);
+                  _builder.append(_genStateId_2, "\t\t\t\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                } else {
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("/* state has a sub graph */");
+                  _builder.newLine();
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  InitialTransition sub_initt = FsmGenExtensions.getInitialTransition(state2node.get(state_1).getSubgraph());
+                  _builder.newLineIfNotEmpty();
+                  {
+                    if ((sub_initt != null)) {
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("/* with init transition */");
+                      _builder.newLine();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("if (");
+                      String _history = this.getHistory(this._codegenHelpers.getGenStateId(state_1));
+                      _builder.append(_history, "\t\t\t\t");
+                      _builder.append("==NO_STATE) {");
+                      _builder.newLineIfNotEmpty();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("state__et = executeTransitionChain(");
+                      String _selfPointer_2 = this.langExt.selfPointer(true);
+                      _builder.append(_selfPointer_2, "\t\t\t\t\t");
+                      _builder.append(chainIDScope, "\t\t\t\t\t");
+                      String _genChainId_1 = this._codegenHelpers.getGenChainId(sub_initt);
+                      _builder.append(_genChainId_1, "\t\t\t\t\t");
+                      {
+                        if (handleEvents) {
+                          _builder.append(", ");
+                          String _nullPointer = this.langExt.nullPointer();
+                          _builder.append(_nullPointer, "\t\t\t\t\t");
+                          _builder.append(", ");
+                          String _nullPointer_1 = this.langExt.nullPointer();
+                          _builder.append(_nullPointer_1, "\t\t\t\t\t");
+                        }
+                      }
+                      _builder.append(");");
+                      _builder.newLineIfNotEmpty();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("}");
+                      _builder.newLine();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("else {");
+                      _builder.newLine();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("state__et = ");
+                      String _history_1 = this.getHistory(this._codegenHelpers.getGenStateId(state_1));
+                      _builder.append(_history_1, "\t\t\t\t\t");
+                      _builder.append(";");
+                      _builder.newLineIfNotEmpty();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("}");
+                      _builder.newLine();
+                    } else {
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("/* without init transition */");
+                      _builder.newLine();
+                      _builder.append("\t\t\t");
+                      _builder.append("\t");
+                      _builder.append("state__et = ");
+                      String _history_2 = this.getHistory(this._codegenHelpers.getGenStateId(state_1));
+                      _builder.append(_history_2, "\t\t\t\t");
+                      _builder.append(";");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("break;");
+                  _builder.newLine();
+                }
+              }
+            }
+          }
+          _builder.append("\t\t\t");
+          _builder.append("case STATE_TOP:");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("state__et = ");
+          String _history_3 = this.getHistory("STATE_TOP");
+          _builder.append(_history_3, "\t\t\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("default:");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("/* should not occur */");
+          _builder.newLine();
+          _builder.append("\t\t\t\t");
+          _builder.append("break;");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+          {
+            if (needsSkipVar) {
+              _builder.append("\t\t");
+              _builder.append("skip_entry__et = ");
+              String _booleanConstant_3 = this.langExt.booleanConstant(false);
+              _builder.append(_booleanConstant_3, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          String _unreachableReturn = this.unreachableReturn();
+          _builder.append(_unreachableReturn, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+        } else {
+          String _stateType_9 = this.stateType();
+          _builder.append(_stateType_9);
+          _builder.append(" enterHistory(");
+          _builder.append(selfPtr);
+          String _stateType_10 = this.stateType();
+          _builder.append(_stateType_10);
+          _builder.append(" state__et");
+          {
+            if (usesHdlr) {
+              _builder.append(", ");
+              String _boolType_4 = this.boolType();
+              _builder.append(_boolType_4);
+              _builder.append(" handler__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        if (generateImplementation) {
+          _builder.append(publicIf);
+          _builder.append("void ");
+          _builder.append(opScope);
+          _builder.append("executeInitTransition(");
+          _builder.append(selfOnly);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          InitialTransition initt = FsmGenExtensions.getInitialTransition(gc.getGraph());
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("int chain__et = ");
+          _builder.append(chainIDScope, "\t");
+          String _genChainId_2 = this._codegenHelpers.getGenChainId(initt);
+          _builder.append(_genChainId_2, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          String _stateType_11 = this.stateType();
+          _builder.append(_stateType_11, "\t");
+          _builder.append(" next__et = ");
+          _builder.append(opScopePriv, "\t");
+          _builder.append("executeTransitionChain(");
+          String _selfPointer_3 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_3, "\t");
+          _builder.append("chain__et");
+          {
+            if (handleEvents) {
+              _builder.append(", ");
+              String _nullPointer_2 = this.langExt.nullPointer();
+              _builder.append(_nullPointer_2, "\t");
+              _builder.append(", ");
+              String _nullPointer_3 = this.langExt.nullPointer();
+              _builder.append(_nullPointer_3, "\t");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("next__et = ");
+          _builder.append(opScopePriv, "\t");
+          _builder.append("enterHistory(");
+          String _selfPointer_4 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_4, "\t");
+          _builder.append("next__et");
+          {
+            if (usesHdlr) {
+              _builder.append(", ");
+              String _booleanConstant_4 = this.langExt.booleanConstant(false);
+              _builder.append(_booleanConstant_4, "\t");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("setState(");
+          String _selfPointer_5 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_5, "\t");
+          _builder.append("next__et);");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+        } else {
+          _builder.append("void ");
+          _builder.append(opScope);
+          _builder.append("executeInitTransition(");
+          _builder.append(selfOnly);
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("/* receiveEvent contains the main implementation of the FSM */");
+      _builder.newLine();
+      {
+        if (generateImplementation) {
+          _builder.append(publicIf);
+          _builder.append("void ");
+          _builder.append(opScope);
+          _builder.append("receiveEventInternal(");
+          String _selfPointer_6 = this.langExt.selfPointer(this.getClassName(mc), handleEvents);
+          _builder.append(_selfPointer_6);
+          {
+            if (handleEvents) {
+              _builder.append(ifItemPtr);
+              _builder.append(" ifitem, int localId, int evt, ");
+              String _voidPointer_2 = this.langExt.voidPointer();
+              _builder.append(_voidPointer_2);
+              _builder.append(" generic_data__et");
+            }
+          }
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          {
+            if (async) {
+              _builder.append("\t");
+              _builder.append("int trigger__et = (ifitem==");
+              String _nullPointer_4 = this.langExt.nullPointer();
+              _builder.append(_nullPointer_4, "\t");
+              _builder.append(")? POLLING : localId + EVT_SHIFT*evt;");
+              _builder.newLineIfNotEmpty();
+            } else {
+              if (eventDriven) {
+                _builder.append("\t");
+                _builder.append("int trigger__et = localId + EVT_SHIFT*evt;");
+                _builder.newLine();
+              }
+            }
+          }
+          _builder.append("\t");
+          _builder.append("int chain__et = NOT_CAUGHT;");
+          _builder.newLine();
+          _builder.append("\t");
+          String _stateType_12 = this.stateType();
+          _builder.append(_stateType_12, "\t");
+          _builder.append(" catching_state__et = NO_STATE;");
+          _builder.newLineIfNotEmpty();
+          {
+            if (usesHdlr) {
+              _builder.append("\t");
+              String _boolType_5 = this.boolType();
+              _builder.append(_boolType_5, "\t");
+              _builder.append(" is_handler__et = ");
+              String _booleanConstant_5 = this.langExt.booleanConstant(false);
+              _builder.append(_booleanConstant_5, "\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          {
+            if ((async || eventDriven)) {
+              _builder.append("\t");
+              CharSequence _markVariableUsed = this.markVariableUsed("trigger__et");
+              _builder.append(_markVariableUsed, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.newLine();
+          {
+            if (handleEvents) {
+              _builder.append("\t");
+              _builder.append("if (!handleSystemEvent(ifitem, evt, generic_data__et)) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              CharSequence _genStateSwitch = this.genStateSwitch(gc, usesHdlr);
+              _builder.append(_genStateSwitch, "\t\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              _builder.append("\t");
+              CharSequence _genStateSwitch_1 = this.genStateSwitch(gc, usesHdlr);
+              _builder.append(_genStateSwitch_1, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("if (chain__et != NOT_CAUGHT) {");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append(opScopePriv, "\t\t");
+          _builder.append("exitTo(");
+          String _selfPointer_7 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_7, "\t\t");
+          _builder.append("getState(");
+          String _selfPointer_8 = this.langExt.selfPointer(false);
+          _builder.append(_selfPointer_8, "\t\t");
+          _builder.append("), catching_state__et");
+          {
+            if (usesHdlr) {
+              _builder.append(", is_handler__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("{");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          String _stateType_13 = this.stateType();
+          _builder.append(_stateType_13, "\t\t\t");
+          _builder.append(" next__et = ");
+          _builder.append(opScopePriv, "\t\t\t");
+          _builder.append("executeTransitionChain(");
+          String _selfPointer_9 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_9, "\t\t\t");
+          _builder.append("chain__et");
+          {
+            if (handleEvents) {
+              _builder.append(", ifitem, generic_data__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t\t");
+          _builder.append("next__et = ");
+          _builder.append(opScopePriv, "\t\t\t");
+          _builder.append("enterHistory(");
+          String _selfPointer_10 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_10, "\t\t\t");
+          _builder.append("next__et");
+          {
+            if (usesHdlr) {
+              _builder.append(", is_handler__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t\t");
+          _builder.append("setState(");
+          String _selfPointer_11 = this.langExt.selfPointer(true);
+          _builder.append(_selfPointer_11, "\t\t\t");
+          _builder.append("next__et);");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t\t");
+          CharSequence _finalAction = this.finalAction();
+          _builder.append(_finalAction, "\t\t\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        } else {
+          _builder.append("void ");
+          _builder.append(opScope);
+          _builder.append("receiveEventInternal(");
+          String _selfPointer_12 = this.langExt.selfPointer(this.getClassName(mc), handleEvents);
+          _builder.append(_selfPointer_12);
+          {
+            if (handleEvents) {
+              _builder.append(ifItemPtr);
+              _builder.append(" ifitem, int localId, int evt, ");
+              String _voidPointer_3 = this.langExt.voidPointer();
+              _builder.append(_voidPointer_3);
+              _builder.append(" generic_data__et");
+            }
+          }
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        if (handleEvents) {
+          {
+            if (generateImplementation) {
+              _builder.append(publicIf);
+              _builder.append("void ");
+              _builder.append(opScope);
+              _builder.append("receiveEvent(");
+              String _selfPointer_13 = this.langExt.selfPointer(this.getClassName(mc), true);
+              _builder.append(_selfPointer_13);
+              _builder.append(ifItemPtr);
+              _builder.append(" ifitem, int evt, ");
+              String _voidPointer_4 = this.langExt.voidPointer();
+              _builder.append(_voidPointer_4);
+              _builder.append(" generic_data__et) {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("int localId = (ifitem==");
+              String _nullPointer_5 = this.langExt.nullPointer();
+              _builder.append(_nullPointer_5, "\t");
+              _builder.append(")? 0 : ifitem");
+              _builder.append(getLocalId, "\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append(opScope, "\t");
+              _builder.append("receiveEventInternal(");
+              String _selfPointer_14 = this.langExt.selfPointer(true);
+              _builder.append(_selfPointer_14, "\t");
+              _builder.append("ifitem, localId, evt, generic_data__et);");
+              _builder.newLineIfNotEmpty();
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              _builder.append("void ");
+              _builder.append(opScope);
+              _builder.append("receiveEvent(");
+              String _selfPointer_15 = this.langExt.selfPointer(true);
+              _builder.append(_selfPointer_15);
+              _builder.append(ifItemPtr);
+              _builder.append(" ifitem, int evt, ");
+              String _voidPointer_5 = this.langExt.voidPointer();
+              _builder.append(_voidPointer_5);
+              _builder.append(" generic_data__et);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * generate the do code calls for a given state
+   * 
+   * @param state the {@link State}
+   * @return the generated code
+   */
+  public String genDoCodes(final State state) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _hasDoCode = this._fSMHelpers.hasDoCode(state, true);
+      if (_hasDoCode) {
+        String _doCodeOperationName = this._codegenHelpers.getDoCodeOperationName(state);
+        _builder.append(_doCodeOperationName);
+        _builder.append("(");
+        String _selfPointer = this.langExt.selfPointer(false);
+        _builder.append(_selfPointer);
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    {
+      EObject _eContainer = state.eContainer().eContainer();
+      if ((_eContainer instanceof State)) {
+        EObject _eContainer_1 = state.eContainer().eContainer();
+        String _genDoCodes = this.genDoCodes(((State) _eContainer_1));
+        _builder.append(_genDoCodes);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder.toString();
+  }
+  
+  /**
+   * 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
+   */
+  public CharSequence genStateSwitch(final GraphContainer gc, final boolean usesHdlr) {
+    CharSequence _xblockexpression = null;
+    {
+      ComponentCommunicationType _commType = gc.getComponent().getCommType();
+      boolean async = Objects.equal(_commType, ComponentCommunicationType.ASYNCHRONOUS);
+      ComponentCommunicationType _commType_1 = gc.getComponent().getCommType();
+      boolean eventDriven = Objects.equal(_commType_1, ComponentCommunicationType.EVENT_DRIVEN);
+      ComponentCommunicationType _commType_2 = gc.getComponent().getCommType();
+      boolean dataDriven = Objects.equal(_commType_2, ComponentCommunicationType.DATA_DRIVEN);
+      final Function1<Node, Boolean> _function = (Node it) -> {
+        return Boolean.valueOf(FsmGenExtensions.isLeaf(it));
+      };
+      final Function1<Node, String> _function_1 = (Node it) -> {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return this._codegenHelpers.getGenStateId(((State) _stateGraphNode));
+      };
+      final List<Node> allLeafStateNodes = IterableExtensions.<Node, String>sortBy(IteratorExtensions.<Node>toList(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(gc.getGraph()), _function)), _function_1);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("switch (getState(");
+      String _selfPointer = this.langExt.selfPointer(false);
+      _builder.append(_selfPointer);
+      _builder.append(")) {");
+      _builder.newLineIfNotEmpty();
+      {
+        for(final Node stateNode : allLeafStateNodes) {
+          _builder.append("\t");
+          StateGraphNode _stateGraphNode = stateNode.getStateGraphNode();
+          final State state = ((State) _stateGraphNode);
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("case ");
+          String _genStateId = this._codegenHelpers.getGenStateId(state);
+          _builder.append(_genStateId, "\t");
+          _builder.append(":");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t");
+          final EList<CommonTrigger> caughtTriggers = stateNode.getCaughtTriggers();
+          _builder.newLineIfNotEmpty();
+          {
+            if (async) {
+              {
+                boolean _isEmpty = caughtTriggers.isEmpty();
+                boolean _not = (!_isEmpty);
+                if (_not) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("switch(trigger__et) {");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("case POLLING:");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  CharSequence _genDataDrivenTriggers = this.genDataDrivenTriggers(gc, stateNode, usesHdlr);
+                  _builder.append(_genDataDrivenTriggers, "\t\t\t\t");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  _builder.append("break;");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  CharSequence _genEventDrivenTriggers = this.genEventDrivenTriggers(gc, stateNode, usesHdlr);
+                  _builder.append(_genEventDrivenTriggers, "\t\t\t");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("}");
+                  _builder.newLine();
+                } else {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  CharSequence _genDataDrivenTriggers_1 = this.genDataDrivenTriggers(gc, stateNode, usesHdlr);
+                  _builder.append(_genDataDrivenTriggers_1, "\t\t");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            } else {
+              if (dataDriven) {
+                _builder.append("\t");
+                _builder.append("\t");
+                CharSequence _genDataDrivenTriggers_2 = this.genDataDrivenTriggers(gc, stateNode, usesHdlr);
+                _builder.append(_genDataDrivenTriggers_2, "\t\t");
+                _builder.newLineIfNotEmpty();
+              } else {
+                if (eventDriven) {
+                  {
+                    boolean _isEmpty_1 = caughtTriggers.isEmpty();
+                    boolean _not_1 = (!_isEmpty_1);
+                    if (_not_1) {
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("switch(trigger__et) {");
+                      _builder.newLine();
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      CharSequence _genEventDrivenTriggers_1 = this.genEventDrivenTriggers(gc, stateNode, usesHdlr);
+                      _builder.append(_genEventDrivenTriggers_1, "\t\t\t");
+                      _builder.newLineIfNotEmpty();
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("}");
+                      _builder.newLine();
+                    }
+                  }
+                }
+              }
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("break;");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("default:");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("/* should not occur */");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("break;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * 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
+   */
+  public CharSequence genDataDrivenTriggers(final GraphContainer gc, final Node stateNode, final boolean usesHdlr) {
+    CharSequence _xblockexpression = null;
+    {
+      String _xifexpression = null;
+      boolean _usesInheritance = this.langExt.usesInheritance();
+      if (_usesInheritance) {
+        String _className = this.getClassName(gc);
+        String _scopeSeparator = this.langExt.scopeSeparator();
+        _xifexpression = (_className + _scopeSeparator);
+      } else {
+        _xifexpression = "";
+      }
+      final String chainIDScope = _xifexpression;
+      StateGraphNode _stateGraphNode = stateNode.getStateGraphNode();
+      final State state = ((State) _stateGraphNode);
+      StringConcatenation _builder = new StringConcatenation();
+      String _genDoCodes = this.genDoCodes(state);
+      _builder.append(_genDoCodes);
+      _builder.newLineIfNotEmpty();
+      final Function1<Link, Boolean> _function = (Link it) -> {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof GuardedTransition));
+      };
+      Iterable<Link> links = IterableExtensions.<Link>filter(FsmGenExtensions.getOutgoingLinksHierarchically(stateNode), _function);
+      _builder.newLineIfNotEmpty();
+      {
+        for(final Link l : links) {
+          _builder.append("if (");
+          String _genGuardedTransitionGuard = this.genGuardedTransitionGuard(l, "", gc);
+          _builder.append(_genGuardedTransitionGuard);
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+          _builder.append("{");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("chain__et = ");
+          _builder.append(chainIDScope, "\t");
+          String _genChainId = this._codegenHelpers.getGenChainId(l.getTransition());
+          _builder.append(_genChainId, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("catching_state__et = ");
+          String _genStateId = this._codegenHelpers.getGenStateId(this._fSMHelpers.getSuperState(l.getTransition()));
+          _builder.append(_genStateId, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          {
+            if ((FsmGenExtensions.isHandler(l) && usesHdlr)) {
+              _builder.append("\t");
+              _builder.append("is_handler__et = TRUE;");
+              _builder.newLine();
+            }
+          }
+          _builder.append("}");
+          _builder.newLine();
+          {
+            Link _last = IterableExtensions.<Link>last(links);
+            boolean _notEquals = (!Objects.equal(l, _last));
+            if (_notEquals) {
+              _builder.append("else");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * 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
+   */
+  public CharSequence genEventDrivenTriggers(final GraphContainer gc, final Node stateNode, final boolean usesHdlr) {
+    CharSequence _xblockexpression = null;
+    {
+      EList<CommonTrigger> _caughtTriggers = stateNode.getCaughtTriggers();
+      final Function1<CommonTrigger, String> _function = (CommonTrigger it) -> {
+        return this.getTriggerCodeName(it);
+      };
+      final List<CommonTrigger> caughtTriggers = IterableExtensions.<CommonTrigger, String>sortBy(new ArrayList<CommonTrigger>(_caughtTriggers), _function);
+      String _xifexpression = null;
+      boolean _usesInheritance = this.langExt.usesInheritance();
+      if (_usesInheritance) {
+        String _className = this.getClassName(gc);
+        String _scopeSeparator = this.langExt.scopeSeparator();
+        _xifexpression = (_className + _scopeSeparator);
+      } else {
+        _xifexpression = "";
+      }
+      final String chainIDScope = _xifexpression;
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        for(final CommonTrigger ct : caughtTriggers) {
+          _builder.append("case ");
+          String _triggerCodeName = this.getTriggerCodeName(ct);
+          _builder.append(_triggerCodeName);
+          _builder.append(":");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          boolean needData = ct.isHasGuard();
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          {
+            if (needData) {
+              _builder.append("{ ");
+              String _typedDataDefinition = this.langExt.getTypedDataDefinition(ct.getMsg());
+              _builder.append(_typedDataDefinition, "\t");
+            }
+          }
+          _builder.newLineIfNotEmpty();
+          {
+            EList<Link> _links = ct.getLinks();
+            boolean _hasElements = false;
+            for(final Link link : _links) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate(" else ", "\t");
+              }
+              _builder.append("\t");
+              String _genTriggeredTransitionGuard = this.genTriggeredTransitionGuard(link, ct.getTrigger(), gc);
+              _builder.append(_genTriggeredTransitionGuard, "\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("{");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("chain__et = ");
+              _builder.append(chainIDScope, "\t\t");
+              String _genChainId = this._codegenHelpers.getGenChainId(link.getTransition());
+              _builder.append(_genChainId, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("catching_state__et = ");
+              String _genStateId = this._codegenHelpers.getGenStateId(this._fSMHelpers.getSuperState(link.getTransition()));
+              _builder.append(_genStateId, "\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              {
+                if ((FsmGenExtensions.isHandler(link) && usesHdlr)) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("is_handler__et = ");
+                  String _booleanConstant = this.langExt.booleanConstant(true);
+                  _builder.append(_booleanConstant, "\t\t");
+                  _builder.append(";");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          {
+            if (needData) {
+              _builder.append("}");
+            }
+          }
+          _builder.newLineIfNotEmpty();
+          _builder.append("break;");
+          _builder.newLine();
+        }
+      }
+      _builder.append("default:");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("/* should not occur */");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("break;");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public String getClassName(final GraphContainer gc) {
+    return this.getClassName(gc.getComponent());
+  }
+  
+  public String getClassName(final ModelComponent mc) {
+    return mc.getComponentName();
+  }
+  
+  public String getTriggerCodeName(final CommonTrigger tr) {
+    final String[] parts = tr.getTrigger().split(TriggerExtensions.TRIGGER_SEP);
+    String _get = parts[0];
+    String _plus = ("TRIG_" + _get);
+    String _plus_1 = (_plus + "__");
+    String _get_1 = parts[1];
+    return (_plus_1 + _get_1);
+  }
+  
+  /**
+   * getter for history array
+   * 
+   * @param state the ID of the history state
+   * @return the generated code
+   */
+  public String getHistory(final String state) {
+    String _memberAccess = this.langExt.memberAccess();
+    String _plus = (_memberAccess + "history[");
+    String _plus_1 = (_plus + state);
+    return (_plus_1 + "]");
+  }
+  
+  /**
+   * 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
+   */
+  public String setHistory(final String state, final String historyState) {
+    String _memberAccess = this.langExt.memberAccess();
+    String _plus = (_memberAccess + "history[");
+    String _plus_1 = (_plus + state);
+    String _plus_2 = (_plus_1 + "] = ");
+    return (_plus_2 + historyState);
+  }
+  
+  /**
+   * @return the type of (temporary) state variables (defaults to "int")
+   * and has to be signed
+   */
+  public String stateType() {
+    return "int";
+  }
+  
+  /**
+   * allow target language dependent generation of unreachable return in generated enterHistory method.
+   * The default is just a comment.
+   * @return the generated code
+   */
+  public String unreachableReturn() {
+    return "/* 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
+   */
+  public String boolType() {
+    return "boolean";
+  }
+  
+  /**
+   * empty, but may be overridden
+   */
+  public CharSequence finalAction() {
+    StringConcatenation _builder = new StringConcatenation();
+    return _builder;
+  }
+  
+  /**
+   * the type of the interface item passed into the receiveEvent() method
+   */
+  public String interfaceItemType() {
+    return "InterfaceItemBase";
+  }
+  
+  /**
+   * empty, but may be overridden
+   */
+  public CharSequence markVariableUsed(final String varname) {
+    StringConcatenation _builder = new StringConcatenation();
+    return _builder;
+  }
+  
+  /**
+   * 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
+   */
+  public boolean usesHandlerTrPoints(final GraphContainer gc) {
+    final Function1<Node, Boolean> _function = (Node t) -> {
+      StateGraphNode _stateGraphNode = t.getStateGraphNode();
+      return Boolean.valueOf(((TransitionPoint) _stateGraphNode).isHandler());
+    };
+    boolean _isEmpty = IteratorExtensions.isEmpty(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllTransitionPointNodes(gc.getGraph()), _function));
+    return (!_isEmpty);
+  }
+  
+  public abstract String genTriggeredTransitionGuard(final Link link, final String trigger, final GraphContainer mc);
+  
+  public abstract String genGuardedTransitionGuard(final Link link, final String trigger, final GraphContainer mc);
+  
+  public abstract String genActionCodeMethod(final GraphContainer gc, final Link link, final boolean generateImplementation);
+  
+  public abstract String genActionCodeMethods(final GraphContainer gc, final Node node, final boolean generateImplementation);
+}
diff --git a/plugins/org.eclipse.etrice.generator.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.java b/plugins/org.eclipse.etrice.generator.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.java
new file mode 100644
index 000000000..c4befecfc
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.fsm/xtend-gen/org/eclipse/etrice/generator/fsm/generic/FSMExtensions.java
@@ -0,0 +1,169 @@
+/**
+ * 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.generator.fsm.generic;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+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.ModelComponent;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.util.FSMHelpers;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+/**
+ * @author Henrik Rentz-Reichert
+ */
+@SuppressWarnings("all")
+public class FSMExtensions {
+  @Inject
+  @Extension
+  protected FSMHelpers _fSMHelpers;
+  
+  /**
+   * the template type is T
+   * @param l an iterable of type T
+   * @param e a single element of type T
+   * @return the union of the iterable and the element as new list
+   */
+  public <T extends Object> List<T> union(final Iterable<T> l, final T e) {
+    ArrayList<T> ret = new ArrayList<T>();
+    Iterables.<T>addAll(ret, l);
+    ret.add(e);
+    return ret;
+  }
+  
+  /**
+   * the template type is T
+   * @param l1 an iterable of type T
+   * @param l2 a second iterable of type T
+   * @return the union of the two iterables as new list
+   */
+  public <T extends Object> List<T> union(final Iterable<T> l1, final Iterable<T> l2) {
+    ArrayList<T> ret = new ArrayList<T>();
+    Iterables.<T>addAll(ret, l1);
+    Iterables.<T>addAll(ret, l2);
+    return ret;
+  }
+  
+  /**
+   * the template type is T
+   * @param l1 a list of elements of type T
+   * @param l2 a second list of elements of type T
+   * @return a new list with the contents of l1
+   */
+  public <T extends Object> List<T> minus(final List<T> l1, final List<T> l2) {
+    ArrayList<T> ret = new ArrayList<T>(l1);
+    ret.removeAll(l2);
+    return ret;
+  }
+  
+  /**
+   * @param states a list of {@link State}s
+   * @return a list ordered such that leaf states are last
+   */
+  public Iterable<State> getLeafStatesLast(final List<State> states) {
+    Iterable<State> _xblockexpression = null;
+    {
+      final Function1<State, Boolean> _function = (State s) -> {
+        return Boolean.valueOf(this._fSMHelpers.isLeaf(s));
+      };
+      final Iterable<State> leaf = IterableExtensions.<State>filter(states, _function);
+      final Function1<State, Boolean> _function_1 = (State s) -> {
+        boolean _isLeaf = this._fSMHelpers.isLeaf(s);
+        return Boolean.valueOf((!_isLeaf));
+      };
+      final Iterable<State> nonLeaf = IterableExtensions.<State>filter(states, _function_1);
+      _xblockexpression = Iterables.<State>concat(nonLeaf, leaf);
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * @param ac an {@link ActorClass}
+   * @return a list of all leaf states
+   */
+  public List<State> getAllLeafStates(final ModelComponent mc) {
+    return this._fSMHelpers.getLeafStateList(mc.getStateMachine());
+  }
+  
+  /**
+   * @param ac an {@link ActorClass}
+   * @return a list of simple states with leaf states last
+   */
+  public List<State> getAllBaseStatesLeavesLast(final ModelComponent mc) {
+    return IterableExtensions.<State>toList(this.getLeafStatesLast(this._fSMHelpers.getAllBaseStates(mc)));
+  }
+  
+  /**
+   * @param ac an {@link ModelComponent}
+   * @return the number of all inherited states
+   */
+  public int getNumberOfInheritedStates(final ModelComponent mc) {
+    ModelComponent _base = mc.getBase();
+    boolean _equals = Objects.equal(_base, null);
+    if (_equals) {
+      return 0;
+    } else {
+      int _size = this._fSMHelpers.getStateList(mc.getBase().getStateMachine()).size();
+      int _numberOfInheritedStates = this.getNumberOfInheritedStates(mc.getBase());
+      return (_size + _numberOfInheritedStates);
+    }
+  }
+  
+  /**
+   * @param ac an {@link ModelComponent}
+   * @return the number of all inherited base (or simple) states
+   */
+  public int getNumberOfInheritedBaseStates(final ModelComponent ac) {
+    ModelComponent _base = ac.getBase();
+    boolean _equals = Objects.equal(_base, null);
+    if (_equals) {
+      return 0;
+    } else {
+      int _size = this._fSMHelpers.getBaseStateList(ac.getBase().getStateMachine()).size();
+      int _numberOfInheritedBaseStates = this.getNumberOfInheritedBaseStates(ac.getBase());
+      return (_size + _numberOfInheritedBaseStates);
+    }
+  }
+  
+  public boolean isConditionOrGuard(final DetailCode dc) {
+    boolean _xblockexpression = false;
+    {
+      final EObject parent = dc.eContainer();
+      boolean _switchResult = false;
+      boolean _matched = false;
+      if (parent instanceof Guard) {
+        _matched=true;
+        _switchResult = true;
+      }
+      if (!_matched) {
+        if (parent instanceof CPBranchTransition) {
+          _matched=true;
+          DetailCode _condition = ((CPBranchTransition)parent).getCondition();
+          _switchResult = Objects.equal(_condition, dc);
+        }
+      }
+      if (!_matched) {
+        _switchResult = false;
+      }
+      _xblockexpression = _switchResult;
+    }
+    return _xblockexpression;
+  }
+}
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/ActorClassGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/ActorClassGen.xtend
index d573ba315..1bfae882e 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,7 @@ 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.*
 
 @Singleton
 class ActorClassGen extends GenericActorClassGenerator {
@@ -279,7 +280,7 @@ class ActorClassGen extends GenericActorClassGenerator {
 				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 +296,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 +311,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 +326,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();
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..2de886d0c 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,8 +20,14 @@ 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.PrimitiveType
@@ -30,22 +36,15 @@ 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:
@@ -246,11 +245,11 @@ class JavaExtensions implements ILanguageExtension {
 			return newArrayList("", "", "")
 
 		val data = d as VarDecl
-		var typeName = data.refType.type.getName();
-		var castTypeName = typeName;
+		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()
+			typeName = (data.refType.type as PrimitiveType).targetName
+			val ct = (data.refType.type as PrimitiveType).castName
 			if (ct!=null && !ct.isEmpty())
 				castTypeName = ct
 		}
@@ -259,16 +258,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"
 	}
@@ -278,14 +277,14 @@ class JavaExtensions implements ILanguageExtension {
 		val cast = type.targetType
 
 		if (type.primitiveType==null)
-			Long.toString(literal.getLiteralValue())
+			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/NodeGen.xtend b/plugins/org.eclipse.etrice.generator.java/src/org/eclipse/etrice/generator/java/gen/NodeGen.xtend
index 793c38e3e..67e516e5d 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 {
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..d59287f5a 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,7 @@ 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
 
 @Singleton
 class ProtocolClassGen extends GenericProtocolClassGenerator {
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/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.java
new file mode 100644
index 000000000..d7db6a750
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassDataGen.java
@@ -0,0 +1,222 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.HashMap;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.fsm.fSM.ModelComponent;
+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.etricegen.WiredStructureClass;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+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.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ActorClassDataGen {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  public void doGenerate(final Root root) {
+    final HashMap<ActorClass, WiredActorClass> ac2wired = new HashMap<ActorClass, WiredActorClass>();
+    final Function1<WiredStructureClass, Boolean> _function = (WiredStructureClass w) -> {
+      return Boolean.valueOf((w instanceof WiredActorClass));
+    };
+    final Consumer<WiredStructureClass> _function_1 = (WiredStructureClass w) -> {
+      ac2wired.put(((WiredActorClass) w).getActorClass(), ((WiredActorClass) w));
+    };
+    IterableExtensions.<WiredStructureClass>filter(root.getWiredInstances(), _function).forEach(_function_1);
+    final Function1<ActorClass, Boolean> _function_2 = (ActorClass it) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(it));
+    };
+    final Function1<ActorClass, ExpandedActorClass> _function_3 = (ActorClass it) -> {
+      return root.getExpandedActorClass(it);
+    };
+    Iterable<ExpandedActorClass> _map = IterableExtensions.<ActorClass, ExpandedActorClass>map(IterableExtensions.<ActorClass>filter(root.getActorClasses(), _function_2), _function_3);
+    for (final ExpandedActorClass xpac : _map) {
+      {
+        final WiredActorClass wired = ac2wired.get(xpac.getActorClass());
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(xpac.getActorClass());
+        String _path = this._roomExtensions.getPath(xpac.getActorClass());
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(xpac.getActorClass());
+        String _path_1 = this._roomExtensions.getPath(xpac.getActorClass());
+        final String infopath = (_generationInfoPath + _path_1);
+        String _name = xpac.getActorClass().getName();
+        String file = (_name + "_DataObject.java");
+        this.fileIO.generateFile("generating ActorClass implementation", path, infopath, file, this.generate(root, xpac, wired));
+      }
+    }
+  }
+  
+  public CharSequence generate(final Root root, final ExpandedActorClass xpac, final WiredActorClass wired) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      String _name = ac.getName();
+      final String clsname = (_name + "_DataObject");
+      final EList<RoomModel> models = root.getReferencedModels(ac);
+      String _xifexpression = null;
+      ModelComponent _base = ac.getBase();
+      boolean _notEquals = (!Objects.equal(_base, null));
+      if (_notEquals) {
+        String _name_1 = ac.getActorBase().getName();
+        String _plus = ("extends " + _name_1);
+        _xifexpression = (_plus + "_DataObject ");
+      } else {
+        _xifexpression = "";
+      }
+      final String baseClass = _xifexpression;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("package ");
+      String _package = this._roomExtensions.getPackage(ac);
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.IActorClassDataObject;");
+      _builder.newLine();
+      {
+        for(final RoomModel model : models) {
+          _builder.append("import ");
+          String _name_2 = model.getName();
+          _builder.append(_name_2);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("public class ");
+      _builder.append(clsname);
+      _builder.append(" ");
+      _builder.append(baseClass);
+      _builder.append("implements IActorClassDataObject {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        boolean _hasNonEmptyStateMachine = this._roomHelpers.hasNonEmptyStateMachine(ac);
+        if (_hasNonEmptyStateMachine) {
+          _builder.append("\t");
+          _builder.append("// state and history");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("private int state;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("private int[] history;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      CharSequence _attributes = this._procedureHelpers.attributes(ac.getAttributes());
+      _builder.append(_attributes, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        boolean _hasNonEmptyStateMachine_1 = this._roomHelpers.hasNonEmptyStateMachine(ac);
+        if (_hasNonEmptyStateMachine_1) {
+          _builder.append("\t");
+          _builder.append("public int getState() {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("return state;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void setState(int state) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("this.state = state;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public int[] getHistory() {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("return history;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void setHistory(int[] history)  {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("this.history = history;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      CharSequence _attributeSettersGettersImplementation = this._procedureHelpers.attributeSettersGettersImplementation(ac.getAttributes(), ac.getName());
+      _builder.append(_attributeSettersGettersImplementation, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassGen.java
new file mode 100644
index 000000000..257123985
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ActorClassGen.java
@@ -0,0 +1,1673 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.HashMap;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.fsm.fSM.ComponentCommunicationType;
+import org.eclipse.etrice.core.genmodel.builder.GenmodelConstants;
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+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.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.ActorRef;
+import org.eclipse.etrice.core.room.Attribute;
+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.Port;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.ReferenceType;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SAP;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.generic.GenericActorClassGenerator;
+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.generator.java.gen.ConfigGenAddon;
+import org.eclipse.etrice.generator.java.gen.Initialization;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.etrice.generator.java.gen.StateMachineGen;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ActorClassGen extends GenericActorClassGenerator {
+  @Inject
+  protected IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  protected JavaExtensions _javaExtensions;
+  
+  @Inject
+  @Extension
+  protected RoomExtensions _roomExtensions;
+  
+  @Inject
+  protected IDataConfiguration dataConfigExt;
+  
+  protected final ConfigGenAddon configGenAddon;
+  
+  @Inject
+  @Extension
+  protected ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  protected Initialization _initialization;
+  
+  @Inject
+  @Extension
+  protected StateMachineGen _stateMachineGen;
+  
+  @Inject
+  @Extension
+  protected TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  protected FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  public ActorClassGen(final ConfigGenAddon configGenAddon) {
+    this.configGenAddon = configGenAddon;
+  }
+  
+  public void doGenerate(final Root root) {
+    final HashMap<ActorClass, WiredActorClass> ac2wired = new HashMap<ActorClass, WiredActorClass>();
+    final Function1<WiredStructureClass, Boolean> _function = (WiredStructureClass w) -> {
+      return Boolean.valueOf((w instanceof WiredActorClass));
+    };
+    final Consumer<WiredStructureClass> _function_1 = (WiredStructureClass w) -> {
+      ac2wired.put(((WiredActorClass) w).getActorClass(), ((WiredActorClass) w));
+    };
+    IterableExtensions.<WiredStructureClass>filter(root.getWiredInstances(), _function).forEach(_function_1);
+    final Function1<ActorClass, Boolean> _function_2 = (ActorClass it) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(it));
+    };
+    final Function1<ActorClass, ExpandedActorClass> _function_3 = (ActorClass it) -> {
+      return root.getExpandedActorClass(it);
+    };
+    Iterable<ExpandedActorClass> _map = IterableExtensions.<ActorClass, ExpandedActorClass>map(IterableExtensions.<ActorClass>filter(root.getActorClasses(), _function_2), _function_3);
+    for (final ExpandedActorClass xpac : _map) {
+      {
+        final WiredActorClass wired = ac2wired.get(xpac.getActorClass());
+        final boolean manualBehavior = this._roomHelpers.isBehaviorAnnotationPresent(xpac.getActorClass(), "BehaviorManual");
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(xpac.getActorClass());
+        String _path = this._roomExtensions.getPath(xpac.getActorClass());
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(xpac.getActorClass());
+        String _path_1 = this._roomExtensions.getPath(xpac.getActorClass());
+        final String infopath = (_generationInfoPath + _path_1);
+        String file = this._javaExtensions.getJavaFileName(xpac.getActorClass());
+        if (manualBehavior) {
+          file = ("Abstract" + file);
+        }
+        this.fileIO.generateFile("generating ActorClass implementation", path, infopath, file, this.generate(root, xpac, wired, manualBehavior));
+      }
+    }
+  }
+  
+  public CharSequence generate(final Root root, final ExpandedActorClass xpac, final WiredActorClass wired, final boolean manualBehavior) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      String _xifexpression = null;
+      if (manualBehavior) {
+        String _name = ac.getName();
+        _xifexpression = ("Abstract" + _name);
+      } else {
+        _xifexpression = ac.getName();
+      }
+      final String clsname = _xifexpression;
+      final EList<RoomModel> models = root.getReferencedModels(ac);
+      String _xifexpression_1 = null;
+      boolean _isGeneratePersistenceInterface = Main.getSettings().isGeneratePersistenceInterface();
+      if (_isGeneratePersistenceInterface) {
+        _xifexpression_1 = "implements IPersistable ";
+      } else {
+        _xifexpression_1 = "";
+      }
+      final String impPersist = _xifexpression_1;
+      String _name_1 = ac.getName();
+      final String dataObjClass = (_name_1 + "_DataObject");
+      String _xifexpression_2 = null;
+      ActorClass _actorBase = ac.getActorBase();
+      boolean _notEquals = (!Objects.equal(_actorBase, null));
+      if (_notEquals) {
+        _xifexpression_2 = ac.getActorBase().getName();
+      } else {
+        String _xifexpression_3 = null;
+        boolean _isEmpty = this._roomHelpers.getAttribute(ac, "ActorBaseClass", "class").isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          _xifexpression_3 = this._roomHelpers.getAttribute(ac, "ActorBaseClass", "class");
+        } else {
+          String _xifexpression_4 = null;
+          boolean _isGenerateStoreDataObj = Main.getSettings().isGenerateStoreDataObj();
+          if (_isGenerateStoreDataObj) {
+            _xifexpression_4 = "ActorClassFinalActionBase";
+          } else {
+            _xifexpression_4 = "ActorClassBase";
+          }
+          _xifexpression_3 = _xifexpression_4;
+        }
+        _xifexpression_2 = _xifexpression_3;
+      }
+      final String baseClass = _xifexpression_2;
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("package ");
+      String _package = this._roomExtensions.getPackage(ac);
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        boolean _isEmpty_1 = this.dataConfigExt.getDynConfigReadAttributes(ac).isEmpty();
+        boolean _not_1 = (!_isEmpty_1);
+        if (_not_1) {
+          _builder.append("import org.eclipse.etrice.runtime.java.config.DynConfigLock;");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isGeneratePersistenceInterface_1 = Main.getSettings().isGeneratePersistenceInterface();
+        if (_isGeneratePersistenceInterface_1) {
+          _builder.append("import org.eclipse.etrice.runtime.java.modelbase.IPersistable;");
+          _builder.newLine();
+          _builder.append("import java.io.IOException;");
+          _builder.newLine();
+          _builder.append("import java.io.ObjectInput;");
+          _builder.newLine();
+          _builder.append("import java.io.ObjectOutput;");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isGenerateStoreDataObj_1 = Main.getSettings().isGenerateStoreDataObj();
+        if (_isGenerateStoreDataObj_1) {
+          _builder.append("import java.util.Arrays;");
+          _builder.newLine();
+        }
+      }
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.*;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.*;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.debugging.*;");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("import static org.eclipse.etrice.runtime.java.etunit.EtUnit.*;");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        for(final RoomModel model : models) {
+          _builder.append("import ");
+          String _name_2 = model.getName();
+          _builder.append(_name_2);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<ProtocolClass> _referencedProtocolClasses = root.getReferencedProtocolClasses(ac);
+        for(final ProtocolClass pc : _referencedProtocolClasses) {
+          _builder.append("import ");
+          String _package_1 = this._roomExtensions.getPackage(pc);
+          _builder.append(_package_1);
+          _builder.append(".");
+          String _name_3 = pc.getName();
+          _builder.append(_name_3);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        final Function1<ActorRef, Boolean> _function = (ActorRef r) -> {
+          ReferenceType _refType = r.getRefType();
+          return Boolean.valueOf(Objects.equal(_refType, ReferenceType.OPTIONAL));
+        };
+        Iterable<ActorRef> _filter = IterableExtensions.<ActorRef>filter(ac.getActorRefs(), _function);
+        for(final ActorRef sub : _filter) {
+          _builder.append("import ");
+          String _package_2 = this._roomExtensions.getPackage(sub.getType());
+          _builder.append(_package_2);
+          _builder.append(".");
+          String _name_4 = sub.getType().getName();
+          _builder.append(_name_4);
+          _builder.append("Interface;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(ac, 1, true);
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("public ");
+      {
+        if ((manualBehavior || ac.isAbstract())) {
+          _builder.append("abstract ");
+        }
+      }
+      _builder.append("class ");
+      _builder.append(clsname);
+      _builder.append(" extends ");
+      _builder.append(baseClass);
+      _builder.append(" ");
+      _builder.append(impPersist);
+      _builder.append("{");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(ac, 2, false);
+      _builder.append(_userCode_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- ports");
+      _builder.newLine();
+      {
+        List<Port> _endPorts = this._roomHelpers.getEndPorts(ac);
+        for(final Port ep : _endPorts) {
+          _builder.append("\t");
+          _builder.append("protected ");
+          String _portClassName = this._roomExtensions.getPortClassName(ep);
+          _builder.append(_portClassName, "\t");
+          _builder.append(" ");
+          String _name_5 = ep.getName();
+          _builder.append(_name_5, "\t");
+          _builder.append(" = null;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- saps");
+      _builder.newLine();
+      {
+        EList<SAP> _serviceAccessPoints = ac.getServiceAccessPoints();
+        for(final SAP sap : _serviceAccessPoints) {
+          _builder.append("\t");
+          _builder.append("protected ");
+          String _portClassName_1 = this._roomExtensions.getPortClassName(sap);
+          _builder.append(_portClassName_1, "\t");
+          _builder.append(" ");
+          String _name_6 = sap.getName();
+          _builder.append(_name_6, "\t");
+          _builder.append(" = null;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- services");
+      _builder.newLine();
+      {
+        EList<ServiceImplementation> _serviceImplementations = ac.getServiceImplementations();
+        for(final ServiceImplementation svc : _serviceImplementations) {
+          _builder.append("\t");
+          _builder.append("protected ");
+          String _portClassName_2 = this._roomExtensions.getPortClassName(svc);
+          _builder.append(_portClassName_2, "\t");
+          _builder.append(" ");
+          String _name_7 = svc.getSpp().getName();
+          _builder.append(_name_7, "\t");
+          _builder.append(" = null;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- optional actors");
+      _builder.newLine();
+      {
+        final Function1<ActorRef, Boolean> _function_1 = (ActorRef r) -> {
+          ReferenceType _refType = r.getRefType();
+          return Boolean.valueOf(Objects.equal(_refType, ReferenceType.OPTIONAL));
+        };
+        Iterable<ActorRef> _filter_1 = IterableExtensions.<ActorRef>filter(ac.getActorRefs(), _function_1);
+        for(final ActorRef sub_1 : _filter_1) {
+          _builder.append("\t");
+          _builder.append("protected ");
+          String _name_8 = sub_1.getType().getName();
+          _builder.append(_name_8, "\t");
+          {
+            int _multiplicity = sub_1.getMultiplicity();
+            boolean _notEquals_1 = (_multiplicity != 1);
+            if (_notEquals_1) {
+              _builder.append("Replicated");
+            }
+          }
+          _builder.append("Interface ");
+          String _name_9 = sub_1.getName();
+          _builder.append(_name_9, "\t");
+          _builder.append(" = null;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- interface item IDs");
+      _builder.newLine();
+      _builder.append("\t");
+      String _genInterfaceItemConstants = this.genInterfaceItemConstants(xpac);
+      _builder.append(_genInterfaceItemConstants, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      String _genMinMaxConstants = this.configGenAddon.genMinMaxConstants(ac);
+      _builder.append(_genMinMaxConstants, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      CharSequence _attributes = this._procedureHelpers.attributes(ac.getAttributes());
+      _builder.append(_attributes, "\t");
+      _builder.newLineIfNotEmpty();
+      {
+        List<Attribute> _dynConfigReadAttributes = this.dataConfigExt.getDynConfigReadAttributes(ac);
+        for(final Attribute a : _dynConfigReadAttributes) {
+          _builder.append("\t");
+          _builder.append("private DynConfigLock lock_");
+          String _name_10 = a.getName();
+          _builder.append(_name_10, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(ac.getOperations(), ac.getName());
+      _builder.append(_operationsImplementation, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- construction");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(clsname, "\t");
+      _builder.append("(IRTObject parent, String name) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("super(parent, name);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("setClassName(\"");
+      String _name_11 = ac.getName();
+      _builder.append(_name_11, "\t\t");
+      _builder.append("\");");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      CharSequence _attributeInitialization = this._initialization.attributeInitialization(ac.getAttributes(), ac, false);
+      _builder.append(_attributeInitialization, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// own ports");
+      _builder.newLine();
+      {
+        List<Port> _endPorts_1 = this._roomHelpers.getEndPorts(ac);
+        for(final Port ep_1 : _endPorts_1) {
+          _builder.append("\t\t");
+          String _name_12 = ep_1.getName();
+          _builder.append(_name_12, "\t\t");
+          _builder.append(" = new ");
+          String _portClassName_3 = this._roomExtensions.getPortClassName(ep_1);
+          _builder.append(_portClassName_3, "\t\t");
+          _builder.append("(this, \"");
+          String _name_13 = ep_1.getName();
+          _builder.append(_name_13, "\t\t");
+          _builder.append("\", ");
+          String _ifItemId = this.getIfItemId(ep_1);
+          _builder.append(_ifItemId, "\t\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// own saps");
+      _builder.newLine();
+      {
+        EList<SAP> _serviceAccessPoints_1 = ac.getServiceAccessPoints();
+        for(final SAP sap_1 : _serviceAccessPoints_1) {
+          _builder.append("\t\t");
+          String _name_14 = sap_1.getName();
+          _builder.append(_name_14, "\t\t");
+          _builder.append(" = new ");
+          String _portClassName_4 = this._roomExtensions.getPortClassName(sap_1);
+          _builder.append(_portClassName_4, "\t\t");
+          _builder.append("(this, \"");
+          String _name_15 = sap_1.getName();
+          _builder.append(_name_15, "\t\t");
+          _builder.append("\", ");
+          String _ifItemId_1 = this.getIfItemId(sap_1);
+          _builder.append(_ifItemId_1, "\t\t");
+          _builder.append(", 0);");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// own service implementations");
+      _builder.newLine();
+      {
+        EList<ServiceImplementation> _serviceImplementations_1 = ac.getServiceImplementations();
+        for(final ServiceImplementation svc_1 : _serviceImplementations_1) {
+          _builder.append("\t\t");
+          String _name_16 = svc_1.getSpp().getName();
+          _builder.append(_name_16, "\t\t");
+          _builder.append(" = new ");
+          String _portClassName_5 = this._roomExtensions.getPortClassName(svc_1);
+          _builder.append(_portClassName_5, "\t\t");
+          _builder.append("(this, \"");
+          String _name_17 = svc_1.getSpp().getName();
+          _builder.append(_name_17, "\t\t");
+          _builder.append("\", ");
+          String _ifItemId_2 = this.getIfItemId(svc_1.getSpp());
+          _builder.append(_ifItemId_2, "\t\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs = ac.getActorRefs();
+        for(final ActorRef sub_2 : _actorRefs) {
+          {
+            ReferenceType _refType = sub_2.getRefType();
+            boolean _equals = Objects.equal(_refType, ReferenceType.OPTIONAL);
+            if (_equals) {
+              _builder.append("\t\t");
+              String _name_18 = sub_2.getName();
+              _builder.append(_name_18, "\t\t");
+              _builder.append(" = new ");
+              String _name_19 = sub_2.getType().getName();
+              _builder.append(_name_19, "\t\t");
+              {
+                int _multiplicity_1 = sub_2.getMultiplicity();
+                boolean _notEquals_2 = (_multiplicity_1 != 1);
+                if (_notEquals_2) {
+                  _builder.append("Replicated");
+                }
+              }
+              _builder.append("Interface(this, \"");
+              String _name_20 = sub_2.getName();
+              _builder.append(_name_20, "\t\t");
+              _builder.append("\");");
+              _builder.newLineIfNotEmpty();
+            } else {
+              int _multiplicity_2 = sub_2.getMultiplicity();
+              boolean _greaterThan = (_multiplicity_2 > 1);
+              if (_greaterThan) {
+                _builder.append("\t\t");
+                _builder.append("for (int i=0; i<");
+                int _multiplicity_3 = sub_2.getMultiplicity();
+                _builder.append(_multiplicity_3, "\t\t");
+                _builder.append("; ++i) {");
+                _builder.newLineIfNotEmpty();
+                {
+                  boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+                  if (_isGenerateMSCInstrumentation) {
+                    _builder.append("\t\t");
+                    _builder.append("\t");
+                    _builder.append("DebuggingService.getInstance().addMessageActorCreate(this, \"");
+                    String _name_21 = sub_2.getName();
+                    _builder.append(_name_21, "\t\t\t");
+                    _builder.append(GenmodelConstants.INDEX_SEP, "\t\t\t");
+                    _builder.append("\"+i);");
+                    _builder.newLineIfNotEmpty();
+                  }
+                }
+                _builder.append("\t\t");
+                _builder.append("\t");
+                _builder.append("new ");
+                String _name_22 = sub_2.getType().getName();
+                _builder.append(_name_22, "\t\t\t");
+                _builder.append("(this, \"");
+                String _name_23 = sub_2.getName();
+                _builder.append(_name_23, "\t\t\t");
+                _builder.append(GenmodelConstants.INDEX_SEP, "\t\t\t");
+                _builder.append("\"+i);");
+                _builder.newLineIfNotEmpty();
+                _builder.append("\t\t");
+                _builder.append("}");
+                _builder.newLine();
+              } else {
+                {
+                  boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+                  if (_isGenerateMSCInstrumentation_1) {
+                    _builder.append("\t\t");
+                    _builder.append("DebuggingService.getInstance().addMessageActorCreate(this, \"");
+                    String _name_24 = sub_2.getName();
+                    _builder.append(_name_24, "\t\t");
+                    _builder.append("\");");
+                    _builder.newLineIfNotEmpty();
+                  }
+                }
+                _builder.append("\t\t");
+                _builder.append("new ");
+                String _name_25 = sub_2.getType().getName();
+                _builder.append(_name_25, "\t\t");
+                _builder.append("(this, \"");
+                String _name_26 = sub_2.getName();
+                _builder.append(_name_26, "\t\t");
+                _builder.append("\");");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// wiring");
+      _builder.newLine();
+      {
+        EList<Wire> _wires = wired.getWires();
+        for(final Wire wire : _wires) {
+          _builder.append("\t\t");
+          String _xifexpression_5 = null;
+          boolean _isDataDriven = wire.isDataDriven();
+          if (_isDataDriven) {
+            _xifexpression_5 = "DataPortBase";
+          } else {
+            _xifexpression_5 = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression_5, "\t\t");
+          _builder.append(".connect(this, \"");
+          String _join = IterableExtensions.join(wire.getPath1(), "/");
+          _builder.append(_join, "\t\t");
+          _builder.append("\", \"");
+          String _join_1 = IterableExtensions.join(wire.getPath2(), "/");
+          _builder.append(_join_1, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      {
+        if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+          _builder.append("\t\t");
+          _builder.append("// activate polling for data-driven communication");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("RTServices.getInstance().getMsgSvcCtrl().getMsgSvc(getThread()).addPollingMessageReceiver(this);");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      String _userStructorBody = this._procedureHelpers.userStructorBody(ac, true);
+      _builder.append(_userStructorBody, "\t\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        if (((!this.dataConfigExt.getDynConfigReadAttributes(ac).isEmpty()) || (!this.dataConfigExt.getDynConfigWriteAttributes(ac).isEmpty()))) {
+          {
+            List<Attribute> _dynConfigReadAttributes_1 = this.dataConfigExt.getDynConfigReadAttributes(ac);
+            for(final Attribute a_1 : _dynConfigReadAttributes_1) {
+              _builder.append("\t\t");
+              _builder.append("lock_");
+              String _name_27 = a_1.getName();
+              _builder.append(_name_27, "\t\t");
+              _builder.append(" = new DynConfigLock();");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _attributeSettersGettersImplementation = this._procedureHelpers.attributeSettersGettersImplementation(this._roomExtensions.<Attribute>minus(ac.getAttributes(), this.dataConfigExt.getDynConfigReadAttributes(ac)), ac.getName());
+      _builder.append(_attributeSettersGettersImplementation, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _genDynConfigGetterSetter = this.configGenAddon.genDynConfigGetterSetter(ac);
+      _builder.append(_genDynConfigGetterSetter, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- port getters");
+      _builder.newLine();
+      {
+        List<Port> _endPorts_2 = this._roomHelpers.getEndPorts(ac);
+        for(final Port ep_2 : _endPorts_2) {
+          _builder.append("\t");
+          CharSequence _terImplementation = this._procedureHelpers.getterImplementation(this._roomExtensions.getPortClassName(ep_2), ep_2.getName(), ac.getName());
+          _builder.append(_terImplementation, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<SAP> _serviceAccessPoints_2 = ac.getServiceAccessPoints();
+        for(final SAP sap_2 : _serviceAccessPoints_2) {
+          _builder.append("\t");
+          CharSequence _terImplementation_1 = this._procedureHelpers.getterImplementation(this._roomExtensions.getPortClassName(sap_2), sap_2.getName(), ac.getName());
+          _builder.append(_terImplementation_1, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<ServiceImplementation> _serviceImplementations_2 = ac.getServiceImplementations();
+        for(final ServiceImplementation svc_2 : _serviceImplementations_2) {
+          _builder.append("\t");
+          CharSequence _terImplementation_2 = this._procedureHelpers.getterImplementation(this._roomExtensions.getPortClassName(svc_2), svc_2.getSpp().getName(), ac.getName());
+          _builder.append(_terImplementation_2, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("//--------------------- lifecycle functions");
+      _builder.newLine();
+      {
+        boolean _overridesStop = this._roomExtensions.overridesStop(ac);
+        boolean _not_2 = (!_overridesStop);
+        if (_not_2) {
+          {
+            if (manualBehavior) {
+              _builder.append("\t");
+              _builder.append("public abstract void stop();");
+              _builder.newLine();
+            } else {
+              _builder.append("\t");
+              _builder.append("public void stop(){");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("super.stop();");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        if (manualBehavior) {
+          _builder.append("\t");
+          _builder.append("public abstract void destroy();");
+          _builder.newLine();
+        } else {
+          _builder.append("\t");
+          _builder.append("public void destroy(){");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          String _userStructorBody_1 = this._procedureHelpers.userStructorBody(ac, false);
+          _builder.append(_userStructorBody_1, "\t\t");
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation_2) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("DebuggingService.getInstance().addMessageActorDestroy(this);");
+              _builder.newLine();
+            }
+          }
+          {
+            if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("RTServices.getInstance().getMsgSvcCtrl().getMsgSvc(getThread()).removePollingMessageReceiver(this);");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("super.destroy();");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      {
+        if (manualBehavior) {
+          _builder.append("\t");
+          _builder.append("public void receiveEvent(InterfaceItemBase ifitem, int evt, Object generic_data) {");
+          _builder.newLine();
+          {
+            List<InterfaceItem> _allInterfaceItems = this._roomHelpers.getAllInterfaceItems(ac);
+            boolean _hasElements = false;
+            for(final InterfaceItem ifitem : _allInterfaceItems) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate("else ", "\t\t");
+              }
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("if (ifitem==");
+              String _name_28 = ifitem.getName();
+              _builder.append(_name_28, "\t\t");
+              _builder.append(") {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("switch (evt) {");
+              _builder.newLine();
+              {
+                List<Message> _incoming = this._roomHelpers.getIncoming(ifitem);
+                for(final Message msg : _incoming) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  _builder.append("case ");
+                  String _name_29 = this._roomHelpers.getProtocolClass(msg).getName();
+                  _builder.append(_name_29, "\t\t\t\t");
+                  _builder.append(".");
+                  String _xifexpression_6 = null;
+                  boolean _isIncoming = this._roomExtensions.isIncoming(msg);
+                  if (_isIncoming) {
+                    _xifexpression_6 = "IN_";
+                  } else {
+                    _xifexpression_6 = "OUT_";
+                  }
+                  _builder.append(_xifexpression_6, "\t\t\t\t");
+                  String _name_30 = msg.getName();
+                  _builder.append(_name_30, "\t\t\t\t");
+                  _builder.append(":");
+                  _builder.newLineIfNotEmpty();
+                  {
+                    VarDecl _data = msg.getData();
+                    boolean _notEquals_3 = (!Objects.equal(_data, null));
+                    if (_notEquals_3) {
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("\t\t");
+                      _builder.append("\t");
+                      _builder.append("{");
+                      String _typedDataDefinition = this._javaExtensions.getTypedDataDefinition(msg);
+                      _builder.append(_typedDataDefinition, "\t\t\t\t\t");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  _builder.append("\t");
+                  _builder.append("on_");
+                  String _name_31 = ifitem.getName();
+                  _builder.append(_name_31, "\t\t\t\t\t");
+                  _builder.append("_");
+                  String _name_32 = msg.getName();
+                  _builder.append(_name_32, "\t\t\t\t\t");
+                  _builder.append("(ifitem");
+                  {
+                    VarDecl _data_1 = msg.getData();
+                    boolean _notEquals_4 = (!Objects.equal(_data_1, null));
+                    if (_notEquals_4) {
+                      _builder.append(", ");
+                      String _name_33 = msg.getData().getName();
+                      _builder.append(_name_33, "\t\t\t\t\t");
+                    }
+                  }
+                  _builder.append(");");
+                  _builder.newLineIfNotEmpty();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("\t\t");
+                  _builder.append("\t");
+                  _builder.append("break;");
+                  _builder.newLine();
+                  {
+                    VarDecl _data_2 = msg.getData();
+                    boolean _notEquals_5 = (!Objects.equal(_data_2, null));
+                    if (_notEquals_5) {
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("\t\t");
+                      _builder.append("\t");
+                      _builder.append("}");
+                      _builder.newLine();
+                    }
+                  }
+                }
+              }
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          {
+            List<InterfaceItem> _allInterfaceItems_1 = this._roomHelpers.getAllInterfaceItems(ac);
+            for(final InterfaceItem ifitem_1 : _allInterfaceItems_1) {
+              {
+                List<Message> _incoming_1 = this._roomHelpers.getIncoming(ifitem_1);
+                for(final Message msg_1 : _incoming_1) {
+                  _builder.append("\t");
+                  _builder.append("protected void on_");
+                  String _name_34 = ifitem_1.getName();
+                  _builder.append(_name_34, "\t");
+                  _builder.append("_");
+                  String _name_35 = msg_1.getName();
+                  _builder.append(_name_35, "\t");
+                  _builder.append("(InterfaceItemBase ifitem");
+                  {
+                    VarDecl _data_3 = msg_1.getData();
+                    boolean _notEquals_6 = (!Objects.equal(_data_3, null));
+                    if (_notEquals_6) {
+                      String _get = this._javaExtensions.generateArglistAndTypedData(msg_1.getData())[2];
+                      _builder.append(_get, "\t");
+                    }
+                  }
+                  _builder.append(") {}");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public abstract void executeInitTransition();");
+          _builder.newLine();
+        } else {
+          {
+            boolean _hasNonEmptyStateMachine = this._roomHelpers.hasNonEmptyStateMachine(ac);
+            if (_hasNonEmptyStateMachine) {
+              _builder.append("\t");
+              CharSequence _genStateMachine = this._stateMachineGen.genStateMachine(xpac.getGraphContainer());
+              _builder.append(_genStateMachine, "\t");
+              _builder.newLineIfNotEmpty();
+              {
+                ComponentCommunicationType _commType = ac.getCommType();
+                boolean _equals_1 = Objects.equal(_commType, ComponentCommunicationType.DATA_DRIVEN);
+                if (_equals_1) {
+                  _builder.append("\t");
+                  _builder.append("public void receiveEvent(InterfaceItemBase ifitem, int evt, Object generic_data) {");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("handleSystemEvent(ifitem, evt, generic_data);");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("}");
+                  _builder.newLine();
+                }
+              }
+              {
+                if ((Objects.equal(ac.getCommType(), ComponentCommunicationType.ASYNCHRONOUS) || Objects.equal(ac.getCommType(), ComponentCommunicationType.DATA_DRIVEN))) {
+                  _builder.append("\t");
+                  _builder.append("@Override");
+                  _builder.newLine();
+                  _builder.append("\t");
+                  _builder.append("public void receive(Message msg) {");
+                  _builder.newLine();
+                  {
+                    ComponentCommunicationType _commType_1 = ac.getCommType();
+                    boolean _equals_2 = Objects.equal(_commType_1, ComponentCommunicationType.ASYNCHRONOUS);
+                    if (_equals_2) {
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("receiveEvent(null, -1, null);");
+                      _builder.newLine();
+                    } else {
+                      _builder.append("\t");
+                      _builder.append("\t");
+                      _builder.append("receiveEventInternal();");
+                      _builder.newLine();
+                    }
+                  }
+                  _builder.append("\t");
+                  _builder.append("}");
+                  _builder.newLine();
+                }
+              }
+            } else {
+              boolean _isEmpty_2 = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+              if (_isEmpty_2) {
+                _builder.append("\t");
+                _builder.append("//--------------------- no state machine");
+                _builder.newLine();
+                _builder.append("\t");
+                _builder.append("public void receiveEvent(InterfaceItemBase ifitem, int evt, Object data) {");
+                _builder.newLine();
+                _builder.append("\t");
+                _builder.append("\t");
+                _builder.append("handleSystemEvent(ifitem, evt, data);");
+                _builder.newLine();
+                _builder.append("\t");
+                _builder.append("}");
+                _builder.newLine();
+                _builder.newLine();
+                _builder.append("\t");
+                _builder.append("public void executeInitTransition() {}");
+                _builder.newLine();
+              }
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      {
+        boolean _isGeneratePersistenceInterface_2 = Main.getSettings().isGeneratePersistenceInterface();
+        if (_isGeneratePersistenceInterface_2) {
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("@Override");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void saveObject(ObjectOutput output) throws IOException {");
+          _builder.newLine();
+          {
+            boolean _isEmpty_3 = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+            boolean _not_3 = (!_isEmpty_3);
+            if (_not_3) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("// state and history");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("output.writeInt(getState());");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("for (int h: history) output.writeInt(h);");
+              _builder.newLine();
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("saveAttributes(output);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("protected void saveAttributes(ObjectOutput output) throws IOException {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          CharSequence _genSaveImpl = this.genSaveImpl(xpac);
+          _builder.append(_genSaveImpl, "\t\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("@Override");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void loadObject(ObjectInput input) throws IOException, ClassNotFoundException {");
+          _builder.newLine();
+          {
+            boolean _isEmpty_4 = FsmGenExtensions.isEmpty(xpac.getGraphContainer().getGraph());
+            boolean _not_4 = (!_isEmpty_4);
+            if (_not_4) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("// state and history");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("setState(input.readInt());");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("for (int i=0; i<history.length; ++i) history[i] = input.readInt();");
+              _builder.newLine();
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("loadAttributes(input);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("protected void loadAttributes(ObjectInput input) throws IOException, ClassNotFoundException {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          CharSequence _genLoadImpl = this.genLoadImpl(xpac);
+          _builder.append(_genLoadImpl, "\t\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isGenerateStoreDataObj_2 = Main.getSettings().isGenerateStoreDataObj();
+        if (_isGenerateStoreDataObj_2) {
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("protected void store(IActorClassDataObject obj) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("if (!(obj instanceof ");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append("))");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t\t");
+          _builder.append("return;");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append(" dataObject = (");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append(") obj;");
+          _builder.newLineIfNotEmpty();
+          {
+            ActorClass _actorBase_1 = ac.getActorBase();
+            boolean _notEquals_7 = (!Objects.equal(_actorBase_1, null));
+            if (_notEquals_7) {
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("super.store(dataObject);");
+              _builder.newLine();
+            }
+          }
+          {
+            boolean _hasNonEmptyStateMachine_1 = this._roomHelpers.hasNonEmptyStateMachine(ac);
+            if (_hasNonEmptyStateMachine_1) {
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("dataObject.setState(getState());");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("dataObject.setHistory(Arrays.copyOf(history, history.length));");
+              _builder.newLine();
+            }
+          }
+          {
+            boolean _isEmpty_5 = ac.getAttributes().isEmpty();
+            boolean _not_5 = (!_isEmpty_5);
+            if (_not_5) {
+              _builder.newLine();
+              {
+                EList<Attribute> _attributes_1 = ac.getAttributes();
+                for(final Attribute att : _attributes_1) {
+                  {
+                    boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(att.getType().getType());
+                    if (_isEnumerationOrPrimitive) {
+                      {
+                        int _size = att.getSize();
+                        boolean _greaterThan_1 = (_size > 1);
+                        if (_greaterThan_1) {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("dataObject.set");
+                          String _firstUpper = StringExtensions.toFirstUpper(att.getName());
+                          _builder.append(_firstUpper, "\t\t");
+                          _builder.append("(Arrays.copyOf(");
+                          String _name_36 = att.getName();
+                          _builder.append(_name_36, "\t\t");
+                          _builder.append(", ");
+                          String _name_37 = att.getName();
+                          _builder.append(_name_37, "\t\t");
+                          _builder.append(".length));");
+                          _builder.newLineIfNotEmpty();
+                        } else {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("dataObject.set");
+                          String _firstUpper_1 = StringExtensions.toFirstUpper(att.getName());
+                          _builder.append(_firstUpper_1, "\t\t");
+                          _builder.append("(");
+                          String _name_38 = att.getName();
+                          _builder.append(_name_38, "\t\t");
+                          _builder.append(");");
+                          _builder.newLineIfNotEmpty();
+                        }
+                      }
+                    } else {
+                      {
+                        int _size_1 = att.getSize();
+                        boolean _greaterThan_2 = (_size_1 > 1);
+                        if (_greaterThan_2) {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("{");
+                          _builder.newLine();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          String _name_39 = att.getType().getType().getName();
+                          _builder.append(_name_39, "\t\t\t");
+                          _builder.append("[] arr = Arrays.copyOf(");
+                          String _name_40 = att.getName();
+                          _builder.append(_name_40, "\t\t\t");
+                          _builder.append(", ");
+                          String _name_41 = att.getName();
+                          _builder.append(_name_41, "\t\t\t");
+                          _builder.append(".length);");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("for(int i=0; i<arr.length; ++i) arr[i] = arr[i].deepCopy();");
+                          _builder.newLine();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("dataObject.set");
+                          String _firstUpper_2 = StringExtensions.toFirstUpper(att.getName());
+                          _builder.append(_firstUpper_2, "\t\t\t");
+                          _builder.append("(arr);");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("}");
+                          _builder.newLine();
+                        } else {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("dataObject.set");
+                          String _firstUpper_3 = StringExtensions.toFirstUpper(att.getName());
+                          _builder.append(_firstUpper_3, "\t\t");
+                          _builder.append("(");
+                          String _name_42 = att.getName();
+                          _builder.append(_name_42, "\t\t");
+                          _builder.append(".deepCopy());");
+                          _builder.newLineIfNotEmpty();
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("protected void restore(IActorClassDataObject obj) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("if (!(obj instanceof ");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append("))");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t\t");
+          _builder.append("return;");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append(" dataObject = (");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append(") obj;");
+          _builder.newLineIfNotEmpty();
+          {
+            ActorClass _actorBase_2 = ac.getActorBase();
+            boolean _notEquals_8 = (!Objects.equal(_actorBase_2, null));
+            if (_notEquals_8) {
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("super.restore(dataObject);");
+              _builder.newLine();
+            }
+          }
+          {
+            boolean _hasNonEmptyStateMachine_2 = this._roomHelpers.hasNonEmptyStateMachine(ac);
+            if (_hasNonEmptyStateMachine_2) {
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("setState(dataObject.getState());");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("history = Arrays.copyOf(dataObject.getHistory(), dataObject.getHistory().length);");
+              _builder.newLine();
+            }
+          }
+          {
+            boolean _isEmpty_6 = ac.getAttributes().isEmpty();
+            boolean _not_6 = (!_isEmpty_6);
+            if (_not_6) {
+              _builder.newLine();
+              {
+                EList<Attribute> _attributes_2 = ac.getAttributes();
+                for(final Attribute att_1 : _attributes_2) {
+                  {
+                    boolean _isEnumerationOrPrimitive_1 = this._typeHelpers.isEnumerationOrPrimitive(att_1.getType().getType());
+                    if (_isEnumerationOrPrimitive_1) {
+                      {
+                        int _size_2 = att_1.getSize();
+                        boolean _greaterThan_3 = (_size_2 > 1);
+                        if (_greaterThan_3) {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("set");
+                          String _firstUpper_4 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_4, "\t\t");
+                          _builder.append("(Arrays.copyOf(dataObject.get");
+                          String _firstUpper_5 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_5, "\t\t");
+                          _builder.append("(), ");
+                          String _name_43 = att_1.getName();
+                          _builder.append(_name_43, "\t\t");
+                          _builder.append(".length));");
+                          _builder.newLineIfNotEmpty();
+                        } else {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("set");
+                          String _firstUpper_6 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_6, "\t\t");
+                          _builder.append("(dataObject.get");
+                          String _firstUpper_7 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_7, "\t\t");
+                          _builder.append("());");
+                          _builder.newLineIfNotEmpty();
+                        }
+                      }
+                    } else {
+                      {
+                        int _size_3 = att_1.getSize();
+                        boolean _greaterThan_4 = (_size_3 > 1);
+                        if (_greaterThan_4) {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("{");
+                          _builder.newLine();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          String _name_44 = att_1.getType().getType().getName();
+                          _builder.append(_name_44, "\t\t\t");
+                          _builder.append("[] arr = Arrays.copyOf(dataObject.get");
+                          String _firstUpper_8 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_8, "\t\t\t");
+                          _builder.append("(), ");
+                          String _name_45 = att_1.getName();
+                          _builder.append(_name_45, "\t\t\t");
+                          _builder.append(".length);");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("for(int i=0; i<arr.length; ++i) arr[i] = arr[i].deepCopy();");
+                          _builder.newLine();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("set");
+                          String _firstUpper_9 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_9, "\t\t\t");
+                          _builder.append("(arr);");
+                          _builder.newLineIfNotEmpty();
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("}");
+                          _builder.newLine();
+                        } else {
+                          _builder.append("\t");
+                          _builder.append("\t");
+                          _builder.append("set");
+                          String _firstUpper_10 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_10, "\t\t");
+                          _builder.append("(dataObject.get");
+                          String _firstUpper_11 = StringExtensions.toFirstUpper(att_1.getName());
+                          _builder.append(_firstUpper_11, "\t\t");
+                          _builder.append("().deepCopy());");
+                          _builder.newLineIfNotEmpty();
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("protected ");
+          _builder.append(dataObjClass, "\t");
+          _builder.append(" newDataObject() {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("return new ");
+          _builder.append(dataObjClass, "\t\t");
+          _builder.append("();");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genSaveImpl(final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        ActorClass _actorBase = ac.getActorBase();
+        boolean _notEquals = (!Objects.equal(_actorBase, null));
+        if (_notEquals) {
+          _builder.append("super.saveAttributes(output);");
+          _builder.newLine();
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isEmpty = ac.getAttributes().isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          {
+            EList<Attribute> _attributes = ac.getAttributes();
+            for(final Attribute att : _attributes) {
+              {
+                boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(att.getType().getType());
+                if (_isEnumerationOrPrimitive) {
+                  String _genSavePrimitive = this.genSavePrimitive(att);
+                  _builder.append(_genSavePrimitive);
+                  _builder.newLineIfNotEmpty();
+                } else {
+                  {
+                    int _size = att.getSize();
+                    boolean _greaterThan = (_size > 1);
+                    if (_greaterThan) {
+                      _builder.append("for (");
+                      String _name = att.getType().getType().getName();
+                      _builder.append(_name);
+                      _builder.append(" v: ");
+                      String _name_1 = att.getName();
+                      _builder.append(_name_1);
+                      _builder.append(") output.writeObject(v);");
+                      _builder.newLineIfNotEmpty();
+                    } else {
+                      _builder.append("output.writeObject(");
+                      String _name_2 = att.getName();
+                      _builder.append(_name_2);
+                      _builder.append(");");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genLoadImpl(final ExpandedActorClass xpac) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = xpac.getActorClass();
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        ActorClass _actorBase = ac.getActorBase();
+        boolean _notEquals = (!Objects.equal(_actorBase, null));
+        if (_notEquals) {
+          _builder.append("super.loadAttributes(input);");
+          _builder.newLine();
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isEmpty = ac.getAttributes().isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          {
+            EList<Attribute> _attributes = ac.getAttributes();
+            for(final Attribute att : _attributes) {
+              {
+                boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(att.getType().getType());
+                if (_isEnumerationOrPrimitive) {
+                  String _genLoadPrimitive = this.genLoadPrimitive(att);
+                  _builder.append(_genLoadPrimitive);
+                  _builder.newLineIfNotEmpty();
+                } else {
+                  {
+                    int _size = att.getSize();
+                    boolean _greaterThan = (_size > 1);
+                    if (_greaterThan) {
+                      _builder.append("for (int i=0; i< ");
+                      String _name = att.getName();
+                      _builder.append(_name);
+                      _builder.append(".length; ++i) ");
+                      String _name_1 = att.getName();
+                      _builder.append(_name_1);
+                      _builder.append("[i] = (");
+                      String _name_2 = att.getType().getType().getName();
+                      _builder.append(_name_2);
+                      _builder.append(") input.readObject();");
+                      _builder.newLineIfNotEmpty();
+                    } else {
+                      String _name_3 = att.getName();
+                      _builder.append(_name_3);
+                      _builder.append(" = (");
+                      String _name_4 = att.getType().getType().getName();
+                      _builder.append(_name_4);
+                      _builder.append(") input.readObject();");
+                      _builder.newLineIfNotEmpty();
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String genSavePrimitive(final Attribute att) {
+    String _xblockexpression = null;
+    {
+      String _xifexpression = null;
+      if (((att.getType().getType() instanceof EnumerationType) && Objects.equal(((EnumerationType) att.getType().getType()).getPrimitiveType(), null))) {
+        _xifexpression = "int";
+      } else {
+        _xifexpression = this._typeHelpers.typeName(att.getType().getType());
+      }
+      final String type = _xifexpression;
+      final String method = this.getSaveMethod(type);
+      String _xifexpression_1 = null;
+      int _size = att.getSize();
+      boolean _greaterThan = (_size > 0);
+      if (_greaterThan) {
+        String _name = att.getName();
+        String _plus = ((("for (" + type) + " v: ") + _name);
+        String _plus_1 = (_plus + ") output.");
+        String _plus_2 = (_plus_1 + method);
+        _xifexpression_1 = (_plus_2 + "(v);");
+      } else {
+        String _name_1 = att.getName();
+        String _plus_3 = ((("output." + method) + "(") + _name_1);
+        _xifexpression_1 = (_plus_3 + ");");
+      }
+      _xblockexpression = _xifexpression_1;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getSaveMethod(final String type) {
+    String _switchResult = null;
+    if (type != null) {
+      switch (type) {
+        case "boolean":
+          _switchResult = "writeBoolean";
+          break;
+        case "char":
+          _switchResult = "writeChar";
+          break;
+        case "byte":
+          _switchResult = "writeByte";
+          break;
+        case "short":
+          _switchResult = "writeShort";
+          break;
+        case "int":
+          _switchResult = "write";
+          break;
+        case "long":
+          _switchResult = "writeLong";
+          break;
+        case "float":
+          _switchResult = "writeFloat";
+          break;
+        case "double":
+          _switchResult = "writeDouble";
+          break;
+        case "String":
+          _switchResult = "writeUTF";
+          break;
+      }
+    }
+    return _switchResult;
+  }
+  
+  private String genLoadPrimitive(final Attribute att) {
+    String _xblockexpression = null;
+    {
+      String _xifexpression = null;
+      if (((att.getType().getType() instanceof EnumerationType) && Objects.equal(((EnumerationType) att.getType().getType()).getPrimitiveType(), null))) {
+        _xifexpression = "int";
+      } else {
+        _xifexpression = this._typeHelpers.typeName(att.getType().getType());
+      }
+      final String type = _xifexpression;
+      final String method = this.getLoadMethod(type);
+      String _xifexpression_1 = null;
+      int _size = att.getSize();
+      boolean _greaterThan = (_size > 0);
+      if (_greaterThan) {
+        String _name = att.getName();
+        String _plus = ("for (int i=0; i<" + _name);
+        String _plus_1 = (_plus + ".length; ++i) ");
+        String _name_1 = att.getName();
+        String _plus_2 = (_plus_1 + _name_1);
+        String _plus_3 = (_plus_2 + "[i] = input.");
+        String _plus_4 = (_plus_3 + method);
+        _xifexpression_1 = (_plus_4 + "();");
+      } else {
+        String _name_2 = att.getName();
+        String _plus_5 = (_name_2 + " = input.");
+        String _plus_6 = (_plus_5 + method);
+        _xifexpression_1 = (_plus_6 + "();");
+      }
+      _xblockexpression = _xifexpression_1;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getLoadMethod(final String type) {
+    String _switchResult = null;
+    if (type != null) {
+      switch (type) {
+        case "boolean":
+          _switchResult = "readBoolean";
+          break;
+        case "char":
+          _switchResult = "readChar";
+          break;
+        case "byte":
+          _switchResult = "readByte";
+          break;
+        case "short":
+          _switchResult = "readShort";
+          break;
+        case "int":
+          _switchResult = "read";
+          break;
+        case "long":
+          _switchResult = "readLong";
+          break;
+        case "float":
+          _switchResult = "readFloat";
+          break;
+        case "double":
+          _switchResult = "readDouble";
+          break;
+        case "String":
+          _switchResult = "readUTF";
+          break;
+      }
+    }
+    return _switchResult;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.java
new file mode 100644
index 000000000..d9546d831
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ConfigGenAddon.java
@@ -0,0 +1,448 @@
+/**
+ * Copyright (c) 2012 Juergen Haug
+ * 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
+ */
+package org.eclipse.etrice.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+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.PortClass;
+import org.eclipse.etrice.core.room.PrimitiveType;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+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.gen.Initialization;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+public class ConfigGenAddon {
+  @Inject
+  @Extension
+  private JavaExtensions stdExt;
+  
+  @Inject
+  @Extension
+  private TypeHelpers typeHelpers;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers helpers;
+  
+  @Inject
+  private IDataConfiguration dataConfigExt;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  private Initialization initGen;
+  
+  public CharSequence genActorInstanceConfig(final ActorInstance ai, final String aiVariableName) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(ai.getActorClass());
+      for(final Attribute a : _allAttributes) {
+        CharSequence _applyInstanceConfig = this.applyInstanceConfig(ai, aiVariableName, this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a));
+        _builder.append(_applyInstanceConfig);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    {
+      EList<InterfaceItemInstance> _orderedIfItemInstances = ai.getOrderedIfItemInstances();
+      for(final InterfaceItemInstance pi : _orderedIfItemInstances) {
+        PortClass _portClass = this._roomHelpers.getPortClass(pi.getInterfaceItem());
+        EList<Attribute> _attributes = null;
+        if (_portClass!=null) {
+          _attributes=_portClass.getAttributes();
+        }
+        EList<Attribute> attribs = _attributes;
+        _builder.newLineIfNotEmpty();
+        {
+          boolean _notEquals = (!Objects.equal(attribs, null));
+          if (_notEquals) {
+            {
+              for(final Attribute a_1 : attribs) {
+                CharSequence _invokeGetter = this.helpers.invokeGetter(pi.getName(), null);
+                String _plus = ((aiVariableName + ".") + _invokeGetter);
+                CharSequence _applyInstanceConfig_1 = this.applyInstanceConfig(pi, _plus, this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a_1));
+                _builder.append(_applyInstanceConfig_1);
+                _builder.newLineIfNotEmpty();
+              }
+            }
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence applyInstanceConfig(final InstanceBase instance, final String invokes, final List<Attribute> path) {
+    CharSequence _xblockexpression = null;
+    {
+      Attribute a = IterableExtensions.<Attribute>last(path);
+      DataType aType = a.getType().getType();
+      CharSequence _switchResult = null;
+      boolean _matched = false;
+      if (aType instanceof PrimitiveType) {
+        _matched=true;
+        CharSequence _xblockexpression_1 = null;
+        {
+          String value = this.typeHelpers.getAttrInstanceConfigValue(path, instance);
+          CharSequence _xifexpression = null;
+          boolean _notEquals = (!Objects.equal(value, null));
+          if (_notEquals) {
+            _xifexpression = this.initGen.genAttributeInitializer(a, this.stdExt.toValueLiteral(((PrimitiveType)aType), value), invokes);
+          }
+          _xblockexpression_1 = _xifexpression;
+        }
+        _switchResult = _xblockexpression_1;
+      }
+      if (!_matched) {
+        if (aType instanceof EnumerationType) {
+          _matched=true;
+          CharSequence _xblockexpression_1 = null;
+          {
+            String value = this.typeHelpers.getAttrInstanceConfigValue(path, instance);
+            CharSequence _xifexpression = null;
+            boolean _notEquals = (!Objects.equal(value, null));
+            if (_notEquals) {
+              _xifexpression = this.initGen.genAttributeInitializer(a, value, invokes);
+            }
+            _xblockexpression_1 = _xifexpression;
+          }
+          _switchResult = _xblockexpression_1;
+        }
+      }
+      if (!_matched) {
+        if (aType instanceof DataClass) {
+          _matched=true;
+          StringConcatenation _builder = new StringConcatenation();
+          {
+            List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(((DataClass) aType));
+            for(final Attribute e : _allAttributes) {
+              CharSequence _invokeGetter = this.helpers.invokeGetter(a.getName(), null);
+              String _plus = ((invokes + ".") + _invokeGetter);
+              CharSequence _applyInstanceConfig = this.applyInstanceConfig(instance, _plus, this._roomExtensions.<Attribute>union(path, e));
+              _builder.append(_applyInstanceConfig);
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _switchResult = _builder;
+        }
+      }
+      _xblockexpression = _switchResult;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence genDynConfigGetterSetter(final ActorClass ac) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      List<Attribute> _dynConfigReadAttributes = this.dataConfigExt.getDynConfigReadAttributes(ac);
+      for(final Attribute a : _dynConfigReadAttributes) {
+        _builder.append("public ");
+        String _typeName = this.typeHelpers.typeName(a.getType().getType());
+        _builder.append(_typeName);
+        {
+          int _size = a.getSize();
+          boolean _greaterThan = (_size > 0);
+          if (_greaterThan) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" get");
+        String _firstUpper = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper);
+        _builder.append("(){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("if(lock_");
+        String _name = a.getName();
+        _builder.append(_name, "\t");
+        _builder.append(" == null)");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("return ");
+        String _name_1 = a.getName();
+        _builder.append(_name_1, "\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("else");
+        _builder.newLine();
+        _builder.append("\t\t");
+        _builder.append("synchronized(lock_");
+        String _name_2 = a.getName();
+        _builder.append(_name_2, "\t\t");
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t\t");
+        _builder.append("return ");
+        String _name_3 = a.getName();
+        _builder.append(_name_3, "\t\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("public void set");
+        String _firstUpper_1 = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper_1);
+        _builder.append("(");
+        String _typeName_1 = this.typeHelpers.typeName(a.getType().getType());
+        _builder.append(_typeName_1);
+        {
+          int _size_1 = a.getSize();
+          boolean _greaterThan_1 = (_size_1 > 0);
+          if (_greaterThan_1) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" ");
+        String _name_4 = a.getName();
+        _builder.append(_name_4);
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("if(lock_");
+        String _name_5 = a.getName();
+        _builder.append(_name_5, "\t");
+        _builder.append(" == null)");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("this.");
+        String _name_6 = a.getName();
+        _builder.append(_name_6, "\t\t");
+        _builder.append(" = ");
+        String _name_7 = a.getName();
+        _builder.append(_name_7, "\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("else");
+        _builder.newLine();
+        _builder.append("\t\t");
+        _builder.append("synchronized(lock_");
+        String _name_8 = a.getName();
+        _builder.append(_name_8, "\t\t");
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t\t");
+        _builder.append("this.");
+        String _name_9 = a.getName();
+        _builder.append(_name_9, "\t\t\t");
+        _builder.append(" = ");
+        String _name_10 = a.getName();
+        _builder.append(_name_10, "\t\t\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("}");
+        _builder.newLine();
+        _builder.append("public DynConfigLock get");
+        String _firstUpper_2 = StringExtensions.toFirstUpper(a.getName());
+        _builder.append(_firstUpper_2);
+        _builder.append("Lock(){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("return lock_");
+        String _name_11 = a.getName();
+        _builder.append(_name_11, "\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}\t");
+        _builder.newLine();
+      }
+    }
+    {
+      List<Attribute> _dynConfigWriteAttributes = this.dataConfigExt.getDynConfigWriteAttributes(ac);
+      for(final Attribute a_1 : _dynConfigWriteAttributes) {
+        _builder.append("public void setAndWrite");
+        String _firstUpper_3 = StringExtensions.toFirstUpper(a_1.getName());
+        _builder.append(_firstUpper_3);
+        _builder.append("(");
+        String _typeName_2 = this.typeHelpers.typeName(a_1.getType().getType());
+        _builder.append(_typeName_2);
+        {
+          int _size_2 = a_1.getSize();
+          boolean _greaterThan_2 = (_size_2 > 0);
+          if (_greaterThan_2) {
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" ");
+        String _name_12 = a_1.getName();
+        _builder.append(_name_12);
+        _builder.append("){");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("set");
+        String _firstUpper_4 = StringExtensions.toFirstUpper(a_1.getName());
+        _builder.append(_firstUpper_4, "\t\t");
+        _builder.append("(");
+        String _name_13 = a_1.getName();
+        _builder.append(_name_13, "\t\t");
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("getVariableService().write(this.getInstancePath()+\"/");
+        String _name_14 = a_1.getName();
+        _builder.append(_name_14, "\t\t");
+        _builder.append("\", ");
+        String _name_15 = a_1.getName();
+        _builder.append(_name_15, "\t\t");
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  public String genMinMaxConstants(final ActorClass ac) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(ac);
+      for(final Attribute a : _allAttributes) {
+        CharSequence _genMinMaxConstantsRec = this.genMinMaxConstantsRec(ac, a.getName(), this._roomExtensions.<Attribute>union(new ArrayList<Attribute>(), a));
+        _builder.append(_genMinMaxConstantsRec);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    String result = _builder.toString();
+    int _length = result.length();
+    boolean _notEquals = (_length != 0);
+    if (_notEquals) {
+      StringConcatenation _builder_1 = new StringConcatenation();
+      _builder_1.append("//--------------------- Attribute Specifications");
+      String _plus = (result + _builder_1);
+      result = _plus;
+    }
+    return result;
+  }
+  
+  private CharSequence genMinMaxConstantsRec(final ActorClass ac, final String varNamePath, final List<Attribute> path) {
+    CharSequence _xblockexpression = null;
+    {
+      DataType aType = IterableExtensions.<Attribute>last(path).getType().getType();
+      CharSequence _switchResult = null;
+      boolean _matched = false;
+      if (aType instanceof DataClass) {
+        _matched=true;
+        StringConcatenation _builder = new StringConcatenation();
+        {
+          List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(((DataClass) aType));
+          for(final Attribute e : _allAttributes) {
+            String _name = e.getName();
+            String _plus = ((varNamePath + "_") + _name);
+            CharSequence _genMinMaxConstantsRec = this.genMinMaxConstantsRec(ac, _plus, this._roomExtensions.<Attribute>union(path, e));
+            _builder.append(_genMinMaxConstantsRec);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+        _switchResult = _builder;
+      }
+      if (!_matched) {
+        if (aType instanceof PrimitiveType) {
+          _matched=true;
+          CharSequence _xblockexpression_1 = null;
+          {
+            String temp = ((String) null);
+            StringConcatenation _builder = new StringConcatenation();
+            {
+              boolean _notEquals = (!Objects.equal((temp = this.dataConfigExt.getAttrClassConfigMinValue(ac, path)), null));
+              if (_notEquals) {
+                _builder.append("public static ");
+                String _minMaxType = this.getMinMaxType(((PrimitiveType)aType));
+                _builder.append(_minMaxType);
+                _builder.append(" MIN_");
+                _builder.append(varNamePath);
+                _builder.append(" = ");
+                String _valueLiteral = this.stdExt.toValueLiteral(((PrimitiveType)aType), temp);
+                _builder.append(_valueLiteral);
+                _builder.append(";");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+            {
+              boolean _notEquals_1 = (!Objects.equal((temp = this.dataConfigExt.getAttrClassConfigMaxValue(ac, path)), null));
+              if (_notEquals_1) {
+                _builder.append("public static ");
+                String _minMaxType_1 = this.getMinMaxType(((PrimitiveType)aType));
+                _builder.append(_minMaxType_1);
+                _builder.append(" MAX_");
+                _builder.append(varNamePath);
+                _builder.append(" = ");
+                String _valueLiteral_1 = this.stdExt.toValueLiteral(((PrimitiveType)aType), temp);
+                _builder.append(_valueLiteral_1);
+                _builder.append(";");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+            _xblockexpression_1 = _builder;
+          }
+          _switchResult = _xblockexpression_1;
+        }
+      }
+      _xblockexpression = _switchResult;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getMinMaxType(final PrimitiveType type) {
+    String _switchResult = null;
+    String _typeName = this.typeHelpers.typeName(type);
+    if (_typeName != null) {
+      switch (_typeName) {
+        case "byte":
+          _switchResult = "int";
+          break;
+        case "short":
+          _switchResult = "int";
+          break;
+        case "float":
+          _switchResult = "double";
+          break;
+        default:
+          _switchResult = this.typeHelpers.typeName(type);
+          break;
+      }
+    } else {
+      _switchResult = this.typeHelpers.typeName(type);
+    }
+    return _switchResult;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/JavaExtensions.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/JavaExtensions.java
new file mode 100644
index 000000000..658dea044
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/JavaExtensions.java
@@ -0,0 +1,565 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+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.PrimitiveType;
+import org.eclipse.etrice.core.room.RoomClass;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.fsm.generic.ILanguageExtensionBase;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class JavaExtensions implements ILanguageExtension {
+  @Inject
+  private TypeHelpers typeHelpers;
+  
+  @Override
+  public String getTypedDataDefinition(final EObject msg) {
+    String _xifexpression = null;
+    if ((msg instanceof Message)) {
+      _xifexpression = this.generateArglistAndTypedData(((Message) msg).getData())[ILanguageExtensionBase.TypedDataKind.DECLARATION_AND_INITIALIZATION.ordinal()];
+    } else {
+      _xifexpression = "";
+    }
+    return _xifexpression;
+  }
+  
+  public String getJavaFileName(final RoomClass rc) {
+    String _name = rc.getName();
+    return (_name + ".java");
+  }
+  
+  public String getJavaFactoryName(final ActorClass rc) {
+    String _name = rc.getName();
+    return (_name + "Factory");
+  }
+  
+  public String getJavaFactoryFileName(final ActorClass rc) {
+    String _javaFactoryName = this.getJavaFactoryName(rc);
+    return (_javaFactoryName + ".java");
+  }
+  
+  public String getJavaScalarInterfaceName(final ActorClass rc) {
+    String _name = rc.getName();
+    return (_name + "Interface");
+  }
+  
+  public String getJavaScalarInterfaceFileName(final ActorClass rc) {
+    String _javaScalarInterfaceName = this.getJavaScalarInterfaceName(rc);
+    return (_javaScalarInterfaceName + ".java");
+  }
+  
+  public String getJavaReplicatedInterfaceName(final ActorClass rc) {
+    String _name = rc.getName();
+    return (_name + "ReplicatedInterface");
+  }
+  
+  public String getJavaReplicatedInterfaceFileName(final ActorClass rc) {
+    String _javaReplicatedInterfaceName = this.getJavaReplicatedInterfaceName(rc);
+    return (_javaReplicatedInterfaceName + ".java");
+  }
+  
+  public String getJavaInterfaceName(final ActorClass ac, final boolean replicated) {
+    String _xifexpression = null;
+    if (replicated) {
+      _xifexpression = this.getJavaReplicatedInterfaceName(ac);
+    } else {
+      _xifexpression = this.getJavaScalarInterfaceName(ac);
+    }
+    return _xifexpression;
+  }
+  
+  public String getJavaInterfaceFileName(final ActorClass ac, final boolean replicated) {
+    String _xifexpression = null;
+    if (replicated) {
+      _xifexpression = this.getJavaReplicatedInterfaceFileName(ac);
+    } else {
+      _xifexpression = this.getJavaScalarInterfaceFileName(ac);
+    }
+    return _xifexpression;
+  }
+  
+  public String getJavaClassName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _name = nr.getName();
+    String _plus = ("Node_" + _name);
+    String _plus_1 = (_plus + "_");
+    String _name_1 = ssi.getName();
+    return (_plus_1 + _name_1);
+  }
+  
+  public String getJavaFileName(final NodeRef nr, final SubSystemInstance ssi) {
+    String _javaClassName = this.getJavaClassName(nr, ssi);
+    return (_javaClassName + ".java");
+  }
+  
+  public String toWrapper(final String type) {
+    String _switchResult = null;
+    if (type != null) {
+      switch (type) {
+        case "int":
+          _switchResult = "Integer";
+          break;
+        case "char":
+          _switchResult = "Character";
+          break;
+        default:
+          _switchResult = StringExtensions.toFirstUpper(type);
+          break;
+      }
+    } else {
+      _switchResult = StringExtensions.toFirstUpper(type);
+    }
+    return _switchResult;
+  }
+  
+  public boolean needsInitialization(final Attribute a) {
+    return (((a.getSize() > 0) || (!this.typeHelpers.isEnumerationOrPrimitive(a.getType().getType()))) || this.typeHelpers.typeName(a.getType().getType()).equals("String"));
+  }
+  
+  @Override
+  public String accessLevelPrivate() {
+    return "private ";
+  }
+  
+  @Override
+  public String accessLevelProtected() {
+    return "protected ";
+  }
+  
+  @Override
+  public String accessLevelPublic() {
+    return "public ";
+  }
+  
+  @Override
+  public String memberAccess() {
+    return "this.";
+  }
+  
+  @Override
+  public String selfPointer(final String classname, final boolean hasArgs) {
+    return "";
+  }
+  
+  @Override
+  public String selfPointer(final boolean hasArgs) {
+    return "";
+  }
+  
+  @Override
+  public String operationScope(final String classname, final boolean isDeclaration) {
+    return "";
+  }
+  
+  @Override
+  public String scopeSeparator() {
+    return ".";
+  }
+  
+  @Override
+  public String memberInDeclaration(final String namespace, final String member) {
+    return member;
+  }
+  
+  @Override
+  public String memberInUse(final String namespace, final String member) {
+    return ((namespace + ".") + member);
+  }
+  
+  @Override
+  public boolean usesInheritance() {
+    return true;
+  }
+  
+  @Override
+  public boolean usesPointers() {
+    return false;
+  }
+  
+  @Override
+  public String genEnumeration(final String name, final List<Pair<String, String>> entries) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      for(final Pair<String, String> entry : entries) {
+        _builder.append("public static final int ");
+        String _first = entry.getFirst();
+        _builder.append(_first);
+        _builder.append(" = ");
+        String _second = entry.getSecond();
+        _builder.append(_second);
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder.toString();
+  }
+  
+  @Override
+  public String booleanConstant(final boolean b) {
+    return Boolean.valueOf(b).toString();
+  }
+  
+  @Override
+  public String pointerLiteral() {
+    return "";
+  }
+  
+  @Override
+  public String nullPointer() {
+    return "null";
+  }
+  
+  @Override
+  public String voidPointer() {
+    return "Object";
+  }
+  
+  @Override
+  public String arrayType(final String type, final int size, final boolean isRef) {
+    return (type + "[]");
+  }
+  
+  @Override
+  public String arrayDeclaration(final String type, final int size, final boolean isRef, final String name) {
+    return (((type + " ") + name) + "[]");
+  }
+  
+  @Override
+  public String superCall(final String baseClassName, final String method, final String args) {
+    return (((("super." + method) + "(") + args) + ");");
+  }
+  
+  @Override
+  public String toValueLiteral(final PrimitiveType type, final String value) {
+    String _xifexpression = null;
+    if (((!this.typeHelpers.isCharacterType(type)) && (value.contains(",") || value.contains("{")))) {
+      String _xblockexpression = null;
+      {
+        String[] singleValues = value.replace("{", "").replace("}", "").trim().split(",");
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("{ ");
+        {
+          boolean _hasElements = false;
+          for(final String v : singleValues) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(", ", "");
+            }
+            String _castValue = this.castValue(type, v.trim());
+            _builder.append(_castValue);
+          }
+        }
+        _builder.append(" }");
+        _xblockexpression = _builder.toString();
+      }
+      _xifexpression = _xblockexpression;
+    } else {
+      _xifexpression = this.castValue(type, value);
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String toEnumLiteral(final EnumerationType type, final String value) {
+    String _xifexpression = null;
+    if ((value.contains(",") || value.contains("{"))) {
+      String _xblockexpression = null;
+      {
+        String[] singleValues = value.replace("{", "").replace("}", "").trim().split(",");
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("{ ");
+        {
+          boolean _hasElements = false;
+          for(final String v : singleValues) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(", ", "");
+            }
+            String _convertStringEnumLiteral = this.convertStringEnumLiteral(type, v.trim());
+            _builder.append(_convertStringEnumLiteral);
+          }
+        }
+        _builder.append(" }");
+        _xblockexpression = _builder.toString();
+      }
+      _xifexpression = _xblockexpression;
+    } else {
+      _xifexpression = this.convertStringEnumLiteral(type, value);
+    }
+    return _xifexpression;
+  }
+  
+  private String convertStringEnumLiteral(final EnumerationType type, final String value) {
+    String v = value;
+    boolean _startsWith = v.startsWith(type.getName());
+    if (_startsWith) {
+      int _length = type.getName().length();
+      int _plus = (_length + 1);
+      v = v.substring(_plus);
+    }
+    EList<EnumLiteral> _literals = type.getLiterals();
+    for (final EnumLiteral l : _literals) {
+      boolean _equals = l.getName().equals(v);
+      if (_equals) {
+        String _name = type.getName();
+        String _plus_1 = (_name + ".");
+        String _name_1 = l.getName();
+        return (_plus_1 + _name_1);
+      }
+    }
+    return null;
+  }
+  
+  private String castValue(final PrimitiveType type, final String value) {
+    String _switchResult = null;
+    String _targetName = type.getTargetName();
+    if (_targetName != null) {
+      switch (_targetName) {
+        case "boolean":
+          _switchResult = value.toLowerCase();
+          break;
+        case "byte":
+          _switchResult = ("(byte)" + value);
+          break;
+        case "short":
+          _switchResult = ("(short)" + value);
+          break;
+        case "int":
+          _switchResult = value;
+          break;
+        case "long":
+          _switchResult = (value + "L");
+          break;
+        case "float":
+          _switchResult = (value + "f");
+          break;
+        case "double":
+          _switchResult = (value + "d");
+          break;
+        case "char":
+          String _xifexpression = null;
+          boolean _isEmpty = value.isEmpty();
+          if (_isEmpty) {
+            _xifexpression = "(char) 0";
+          } else {
+            String _xifexpression_1 = null;
+            int _length = value.length();
+            boolean _equals = (_length == 1);
+            if (_equals) {
+              char _charAt = value.charAt(0);
+              String _plus = ("\'" + Character.valueOf(_charAt));
+              _xifexpression_1 = (_plus + "\'");
+            } else {
+              String _replace = value.replace("\\", "\\\\").replace("\"", "\\\"");
+              String _plus_1 = ("\"" + _replace);
+              _xifexpression_1 = (_plus_1 + "\".toCharArray()");
+            }
+            _xifexpression = _xifexpression_1;
+          }
+          _switchResult = _xifexpression;
+          break;
+        case "String":
+          String _replace_1 = value.replace("\\", "\\\\").replace("\"", "\\\"");
+          String _plus_2 = ("\"" + _replace_1);
+          _switchResult = (_plus_2 + "\"");
+          break;
+        default:
+          String _targetName_1 = type.getTargetName();
+          throw new UnsupportedOperationException(_targetName_1);
+      }
+    } else {
+      String _targetName_1 = type.getTargetName();
+      throw new UnsupportedOperationException(_targetName_1);
+    }
+    return _switchResult;
+  }
+  
+  @Override
+  public String defaultValue(final DataType dt) {
+    String _switchResult = null;
+    boolean _matched = false;
+    if (dt instanceof PrimitiveType) {
+      _matched=true;
+      _switchResult = this.toValueLiteral(((PrimitiveType)dt), ((PrimitiveType)dt).getDefaultValueLiteral());
+    }
+    if (!_matched) {
+      if (dt instanceof EnumerationType) {
+        _matched=true;
+        _switchResult = this.getDefaultValue(((EnumerationType)dt));
+      }
+    }
+    if (!_matched) {
+      if (dt instanceof ExternalType) {
+        _matched=true;
+        String _targetName = ((ExternalType) dt).getTargetName();
+        String _plus = ("new " + _targetName);
+        _switchResult = (_plus + "()");
+      }
+    }
+    if (!_matched) {
+      String _name = dt.getName();
+      String _plus = ("new " + _name);
+      _switchResult = (_plus + "()");
+    }
+    return _switchResult;
+  }
+  
+  public String getDefaultValue(final EnumerationType type) {
+    String _xifexpression = null;
+    boolean _isEmpty = type.getLiterals().isEmpty();
+    if (_isEmpty) {
+      _xifexpression = "";
+    } else {
+      _xifexpression = this.getCastedValue(type.getLiterals().get(0));
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String initializationWithDefaultValues(final DataType dt, final int size) {
+    String _xblockexpression = null;
+    {
+      final String dv = this.defaultValue(dt);
+      String _xifexpression = null;
+      if ((size > 1)) {
+        String _xblockexpression_1 = null;
+        {
+          String res = "{";
+          int i = 0;
+          while ((i < size)) {
+            {
+              res = (res + dv);
+              i = (i + 1);
+              if ((i < size)) {
+                res = (res + ",");
+              }
+            }
+          }
+          _xblockexpression_1 = (res + "}");
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        _xifexpression = dv;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String[] generateArglistAndTypedData(final EObject d) {
+    if ((Objects.equal(d, null) || (!(d instanceof VarDecl)))) {
+      return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList("", "", ""), String.class));
+    }
+    final VarDecl data = ((VarDecl) d);
+    String typeName = data.getRefType().getType().getName();
+    String castTypeName = typeName;
+    DataType _type = data.getRefType().getType();
+    if ((_type instanceof PrimitiveType)) {
+      DataType _type_1 = data.getRefType().getType();
+      typeName = ((PrimitiveType) _type_1).getTargetName();
+      DataType _type_2 = data.getRefType().getType();
+      final String ct = ((PrimitiveType) _type_2).getCastName();
+      if (((!Objects.equal(ct, null)) && (!ct.isEmpty()))) {
+        castTypeName = ct;
+      }
+    } else {
+      DataType _type_3 = data.getRefType().getType();
+      if ((_type_3 instanceof EnumerationType)) {
+        DataType _type_4 = data.getRefType().getType();
+        typeName = this.getTargetType(((EnumerationType) _type_4));
+        DataType _type_5 = data.getRefType().getType();
+        castTypeName = this.getCastType(((EnumerationType) _type_5));
+      }
+    }
+    final String dataArg = (", " + ILanguageExtension.GENERIC_DATA_NAME);
+    final String typedData = (((((typeName + " ") + ILanguageExtension.GENERIC_DATA_NAME) + " = (") + castTypeName) + ") generic_data__et;\n");
+    final String typedArgList = (((", " + typeName) + " ") + ILanguageExtension.GENERIC_DATA_NAME);
+    return ((String[])Conversions.unwrapArray(CollectionLiterals.<String>newArrayList(dataArg, typedData, typedArgList), String.class));
+  }
+  
+  @Override
+  public String getTargetType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getTargetName();
+    } else {
+      _xifexpression = "int";
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String getCastedValue(final EnumLiteral literal) {
+    String _xblockexpression = null;
+    {
+      EObject _eContainer = literal.eContainer();
+      final EnumerationType type = ((EnumerationType) _eContainer);
+      final String cast = this.getTargetType(type);
+      String _xifexpression = null;
+      PrimitiveType _primitiveType = type.getPrimitiveType();
+      boolean _equals = Objects.equal(_primitiveType, null);
+      if (_equals) {
+        _xifexpression = Long.toString(literal.getLiteralValue());
+      } else {
+        String _string = Long.toString(literal.getLiteralValue());
+        String _plus = ((("((" + cast) + ")") + _string);
+        _xifexpression = (_plus + ")");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String getCastType(final EnumerationType type) {
+    String _xifexpression = null;
+    PrimitiveType _primitiveType = type.getPrimitiveType();
+    boolean _notEquals = (!Objects.equal(_primitiveType, null));
+    if (_notEquals) {
+      _xifexpression = type.getPrimitiveType().getCastName();
+    } else {
+      _xifexpression = "int";
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public String makeOverridable() {
+    return "";
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/NodeGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/NodeGen.java
new file mode 100644
index 000000000..ee57b0bd3
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/NodeGen.java
@@ -0,0 +1,794 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.etmap.util.ETMapUtil;
+import org.eclipse.etrice.core.etphys.eTPhys.ExecMode;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.etphys.eTPhys.PhysicalThread;
+import org.eclipse.etrice.core.genmodel.builder.GenmodelConstants;
+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.InstanceBase;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.OptionalActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+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.Wire;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredStructureClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredSubSystemClass;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.ActorRef;
+import org.eclipse.etrice.core.room.CommunicationType;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SubSystemClass;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.fsm.base.Indexed;
+import org.eclipse.etrice.generator.fsm.base.IntelligentSeparator;
+import org.eclipse.etrice.generator.generic.ProcedureHelpers;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.etrice.generator.java.Main;
+import org.eclipse.etrice.generator.java.gen.ConfigGenAddon;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.etrice.generator.java.gen.VariableServiceGen;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class NodeGen {
+  @Inject
+  @Extension
+  private JavaExtensions _javaExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  private IDataConfiguration dataConfigExt;
+  
+  @Inject
+  private ConfigGenAddon configGenAddon;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  private VariableServiceGen varService;
+  
+  @Inject
+  private IDiagnostician diagnostician;
+  
+  public void doGenerate(final Root root) {
+    final HashMap<SubSystemClass, WiredSubSystemClass> sscc2wired = new HashMap<SubSystemClass, WiredSubSystemClass>();
+    final Function1<WiredStructureClass, Boolean> _function = (WiredStructureClass w) -> {
+      return Boolean.valueOf((w instanceof WiredSubSystemClass));
+    };
+    final Consumer<WiredStructureClass> _function_1 = (WiredStructureClass w) -> {
+      sscc2wired.put(((WiredSubSystemClass) w).getSubSystemClass(), ((WiredSubSystemClass) w));
+    };
+    IterableExtensions.<WiredStructureClass>filter(root.getWiredInstances(), _function).forEach(_function_1);
+    Collection<NodeRef> _nodeRefs = ETMapUtil.getNodeRefs();
+    for (final NodeRef nr : _nodeRefs) {
+      List<String> _subSystemInstancePaths = ETMapUtil.getSubSystemInstancePaths(nr);
+      for (final String instpath : _subSystemInstancePaths) {
+        {
+          StructureInstance _instance = root.getInstance(instpath);
+          final SubSystemInstance ssi = ((SubSystemInstance) _instance);
+          if (((!Objects.equal(ssi, null)) && this._fileSystemHelpers.isValidGenerationLocation(ssi.getSubSystemClass()))) {
+            final WiredSubSystemClass wired = sscc2wired.get(ssi.getSubSystemClass());
+            String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(ssi.getSubSystemClass());
+            String _path = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String path = (_generationTargetPath + _path);
+            String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(ssi.getSubSystemClass());
+            String _path_1 = this._roomExtensions.getPath(ssi.getSubSystemClass());
+            final String infopath = (_generationInfoPath + _path_1);
+            final String file = this._javaExtensions.getJavaFileName(nr, ssi);
+            this.checkDataPorts(ssi);
+            final Set<PhysicalThread> usedThreads = ETMapUtil.getUsedThreads(nr, ssi);
+            this.fileIO.generateFile("generating Node implementation", path, infopath, file, this.generate(root, ssi, wired, usedThreads));
+            boolean _hasVariableService = this.dataConfigExt.hasVariableService(ssi);
+            if (_hasVariableService) {
+              this.varService.doGenerate(root, ssi);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  /**
+   * Recursively collect all possible interface instances below a given structure instance.
+   */
+  private HashSet<ActorClass> getOptionalActorClasses(final Root root, final StructureInstance si) {
+    final Function1<EObject, Boolean> _function = (EObject i) -> {
+      return Boolean.valueOf((i instanceof ActorInterfaceInstance));
+    };
+    final Function1<EObject, ActorInterfaceInstance> _function_1 = (EObject aii) -> {
+      return ((ActorInterfaceInstance) aii);
+    };
+    final ArrayList<ActorInterfaceInstance> aifs = Lists.<ActorInterfaceInstance>newArrayList(IteratorExtensions.<EObject, ActorInterfaceInstance>map(IteratorExtensions.<EObject>filter(si.eAllContents(), _function), _function_1));
+    final Function1<ActorInterfaceInstance, ActorClass> _function_2 = (ActorInterfaceInstance aii) -> {
+      return ((ActorInterfaceInstance) aii).getActorClass();
+    };
+    final HashSet<ActorClass> result = Sets.<ActorClass>newHashSet(ListExtensions.<ActorInterfaceInstance, ActorClass>map(aifs, _function_2));
+    for (final ActorInterfaceInstance ai : aifs) {
+      EList<OptionalActorInstance> _optionalInstances = ai.getOptionalInstances();
+      for (final OptionalActorInstance oi : _optionalInstances) {
+        result.addAll(this.getOptionalActorClasses(root, oi));
+      }
+    }
+    return result;
+  }
+  
+  public CharSequence generate(final Root root, final SubSystemInstance comp, final WiredSubSystemClass wired, final Collection<PhysicalThread> usedThreads) {
+    CharSequence _xblockexpression = null;
+    {
+      final SubSystemClass cc = comp.getSubSystemClass();
+      final EList<RoomModel> models = root.getReferencedModels(cc);
+      final NodeRef nr = ETMapUtil.getNodeRef(comp);
+      final String clsname = this._javaExtensions.getJavaClassName(nr, comp);
+      final Function1<PhysicalThread, Boolean> _function = (PhysicalThread t) -> {
+        return Boolean.valueOf(usedThreads.contains(t));
+      };
+      final Iterable<PhysicalThread> threads = IterableExtensions.<PhysicalThread>filter(nr.getType().getThreads(), _function);
+      final HashSet<ActorClass> opt = this.getOptionalActorClasses(root, comp);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("package ");
+      String _package = this._roomExtensions.getPackage(cc);
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.config.IVariableService;");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("import org.eclipse.etrice.runtime.java.debugging.DebuggingService;");
+          _builder.newLine();
+        }
+      }
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.IRTObject;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.IMessageService;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.MessageService;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.MessageServiceController;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.RTServices;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.ActorClassBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.DataPortBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.OptionalActorInterfaceBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.IOptionalActorFactory;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.SubSystemClassBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.InterfaceItemBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.InterfaceItemBroker;");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        for(final RoomModel model : models) {
+          _builder.append("import ");
+          String _name = model.getName();
+          _builder.append(_name);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(cc, 1, false);
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("public class ");
+      _builder.append(clsname);
+      _builder.append(" extends SubSystemClassBase {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        Iterable<Indexed<PhysicalThread>> _indexed = Indexed.<PhysicalThread>indexed(threads);
+        for(final Indexed<PhysicalThread> thread : _indexed) {
+          _builder.append("\t");
+          _builder.append("public static final int ");
+          String _threadId = this.getThreadId(thread.getValue());
+          _builder.append(_threadId, "\t");
+          _builder.append(" = ");
+          int _index0 = thread.getIndex0();
+          _builder.append(_index0, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(cc, 2, false);
+      _builder.append(_userCode_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(clsname, "\t");
+      _builder.append("(IRTObject parent, String name) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("super(parent, name);");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void receiveEvent(InterfaceItemBase ifitem, int evt, Object data){");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void instantiateMessageServices() {");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("IMessageService msgService;");
+      _builder.newLine();
+      {
+        final Function1<PhysicalThread, Long> _function_1 = (PhysicalThread it) -> {
+          long _prio = it.getPrio();
+          return Long.valueOf((-_prio));
+        };
+        List<PhysicalThread> _sortBy = IterableExtensions.<PhysicalThread, Long>sortBy(threads, _function_1);
+        for(final PhysicalThread thread_1 : _sortBy) {
+          {
+            if ((Objects.equal(thread_1.getExecmode(), ExecMode.POLLED) || Objects.equal(thread_1.getExecmode(), ExecMode.MIXED))) {
+              _builder.append("\t\t");
+              _builder.append("msgService = new MessageService(this, MessageService.ExecMode.");
+              String _name_1 = thread_1.getExecmode().getName();
+              _builder.append(_name_1, "\t\t");
+              _builder.append(", ");
+              long _time = thread_1.getTime();
+              _builder.append(_time, "\t\t");
+              _builder.append("L, 0, ");
+              String _threadId_1 = this.getThreadId(thread_1);
+              _builder.append(_threadId_1, "\t\t");
+              _builder.append(", \"MessageService_");
+              String _name_2 = thread_1.getName();
+              _builder.append(_name_2, "\t\t");
+              _builder.append("\" /*, thread_prio */);");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t\t");
+              _builder.append("msgService = new MessageService(this, MessageService.ExecMode.");
+              String _name_3 = thread_1.getExecmode().getName();
+              _builder.append(_name_3, "\t\t");
+              _builder.append(", 0, ");
+              String _threadId_2 = this.getThreadId(thread_1);
+              _builder.append(_threadId_2, "\t\t");
+              _builder.append(", \"MessageService_");
+              String _name_4 = thread_1.getName();
+              _builder.append(_name_4, "\t\t");
+              _builder.append("\" /*, thread_prio */);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t\t");
+          _builder.append("RTServices.getInstance().getMsgSvcCtrl().addMsgSvc(msgService);");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void instantiateActors() {");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// thread mappings");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances = comp.getAllContainedInstances();
+        for(final ActorInstance ai : _allContainedInstances) {
+          _builder.append("\t\t");
+          final ETMapUtil.MappedThread mapped = ETMapUtil.getMappedThread(ai);
+          _builder.newLineIfNotEmpty();
+          {
+            boolean _not = (!(mapped.isImplicit() || mapped.isAsParent()));
+            if (_not) {
+              _builder.append("\t\t");
+              _builder.append("addPathToThread(\"");
+              String _path = ai.getPath();
+              _builder.append(_path, "\t\t");
+              _builder.append("\", ");
+              String _threadId_3 = this.getThreadId(mapped.getThread());
+              _builder.append(_threadId_3, "\t\t");
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// sub actors");
+      _builder.newLine();
+      {
+        EList<ActorRef> _actorRefs = cc.getActorRefs();
+        for(final ActorRef sub : _actorRefs) {
+          {
+            int _multiplicity = sub.getMultiplicity();
+            boolean _greaterThan = (_multiplicity > 1);
+            if (_greaterThan) {
+              _builder.append("\t\t");
+              _builder.append("for (int i=0; i<");
+              int _multiplicity_1 = sub.getMultiplicity();
+              _builder.append(_multiplicity_1, "\t\t");
+              _builder.append("; ++i) {");
+              _builder.newLineIfNotEmpty();
+              {
+                boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+                if (_isGenerateMSCInstrumentation_1) {
+                  _builder.append("\t\t");
+                  _builder.append("\t");
+                  _builder.append("DebuggingService.getInstance().addMessageActorCreate(this, \"");
+                  String _name_5 = sub.getName();
+                  _builder.append(_name_5, "\t\t\t");
+                  _builder.append(GenmodelConstants.INDEX_SEP, "\t\t\t");
+                  _builder.append("\"+i);");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("new ");
+              String _name_6 = sub.getType().getName();
+              _builder.append(_name_6, "\t\t\t");
+              _builder.append("(this, \"");
+              String _name_7 = sub.getName();
+              _builder.append(_name_7, "\t\t\t");
+              _builder.append(GenmodelConstants.INDEX_SEP, "\t\t\t");
+              _builder.append("\"+i);");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              {
+                boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+                if (_isGenerateMSCInstrumentation_2) {
+                  _builder.append("\t\t");
+                  _builder.append("DebuggingService.getInstance().addMessageActorCreate(this, \"");
+                  String _name_8 = sub.getName();
+                  _builder.append(_name_8, "\t\t");
+                  _builder.append("\");");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t\t");
+              _builder.append("new ");
+              String _name_9 = sub.getType().getName();
+              _builder.append(_name_9, "\t\t");
+              _builder.append("(this, \"");
+              String _name_10 = sub.getName();
+              _builder.append(_name_10, "\t\t");
+              _builder.append("\");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// create service brokers in optional actor interfaces");
+      _builder.newLine();
+      {
+        final Function1<AbstractInstance, Boolean> _function_2 = (AbstractInstance inst) -> {
+          return Boolean.valueOf((inst instanceof ActorInterfaceInstance));
+        };
+        final Function1<AbstractInstance, ActorInterfaceInstance> _function_3 = (AbstractInstance inst) -> {
+          return ((ActorInterfaceInstance) inst);
+        };
+        Iterable<ActorInterfaceInstance> _map = IterableExtensions.<AbstractInstance, ActorInterfaceInstance>map(IterableExtensions.<AbstractInstance>filter(this._roomExtensions.getAllSubInstances(comp), _function_2), _function_3);
+        for(final ActorInterfaceInstance aii : _map) {
+          _builder.append("\t\t");
+          _builder.append("{");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("OptionalActorInterfaceBase oai = (OptionalActorInterfaceBase) getObject(\"");
+          String _path_1 = aii.getPath();
+          _builder.append(_path_1, "\t\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+          {
+            EList<ServiceImplInstance> _providedServices = aii.getProvidedServices();
+            for(final ServiceImplInstance svc : _providedServices) {
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("new InterfaceItemBroker(oai, \"");
+              String _fullyQualifiedName = this._roomExtensions.getFullyQualifiedName(svc.getProtocol());
+              _builder.append(_fullyQualifiedName, "\t\t\t");
+              _builder.append("\", 0);");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("InterfaceItemBase.connect(this, \"");
+              String _path_2 = svc.getPath();
+              _builder.append(_path_2, "\t\t\t");
+              _builder.append("\", \"");
+              String _path_3 = aii.getPath();
+              String _plus = (_path_3 + Character.valueOf(InstanceBase.pathDelim));
+              String _fullyQualifiedName_1 = this._roomExtensions.getFullyQualifiedName(svc.getProtocol());
+              String _plus_1 = (_plus + _fullyQualifiedName_1);
+              _builder.append(_plus_1, "\t\t\t");
+              _builder.append("\");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// wiring");
+      _builder.newLine();
+      {
+        EList<Wire> _wires = wired.getWires();
+        for(final Wire wire : _wires) {
+          _builder.append("\t\t");
+          String _xifexpression = null;
+          boolean _isDataDriven = wire.isDataDriven();
+          if (_isDataDriven) {
+            _xifexpression = "DataPortBase";
+          } else {
+            _xifexpression = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression, "\t\t");
+          _builder.append(".connect(this, \"");
+          String _join = IterableExtensions.join(wire.getPath1(), "/");
+          _builder.append(_join, "\t\t");
+          _builder.append("\", \"");
+          String _join_1 = IterableExtensions.join(wire.getPath2(), "/");
+          _builder.append(_join_1, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// apply instance attribute configurations");
+      _builder.newLine();
+      {
+        EList<ActorInstance> _allContainedInstances_1 = comp.getAllContainedInstances();
+        for(final ActorInstance ai_1 : _allContainedInstances_1) {
+          _builder.append("\t\t");
+          final CharSequence cfg = this.configGenAddon.genActorInstanceConfig(ai_1, "inst");
+          _builder.newLineIfNotEmpty();
+          {
+            int _length = cfg.length();
+            boolean _greaterThan_1 = (_length > 0);
+            if (_greaterThan_1) {
+              _builder.append("\t\t");
+              _builder.append("{");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              String _name_11 = ai_1.getActorClass().getName();
+              _builder.append(_name_11, "\t\t\t");
+              _builder.append(" inst = (");
+              String _name_12 = ai_1.getActorClass().getName();
+              _builder.append(_name_12, "\t\t\t");
+              _builder.append(") getObject(\"");
+              String _path_4 = ai_1.getPath();
+              _builder.append(_path_4, "\t\t\t");
+              _builder.append("\");");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("if (inst!=null) {");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t\t");
+              _builder.append(cfg, "\t\t\t\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void init(){");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_3 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_3) {
+          _builder.append("\t\t");
+          _builder.append("DebuggingService.getInstance().addVisibleComment(\"begin sub system initialization\");");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _hasVariableService = this.dataConfigExt.hasVariableService(comp);
+        if (_hasVariableService) {
+          _builder.append("\t\t");
+          _builder.append("variableService = new ");
+          _builder.append(clsname, "\t\t");
+          _builder.append("VariableService(this);");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t\t");
+      _builder.append("super.init();");
+      _builder.newLine();
+      {
+        boolean _hasVariableService_1 = this.dataConfigExt.hasVariableService(comp);
+        if (_hasVariableService_1) {
+          _builder.append("\t\t");
+          _builder.append("variableService.init();");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isGenerateMSCInstrumentation_4 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_4) {
+          _builder.append("\t\t");
+          _builder.append("DebuggingService.getInstance().addVisibleComment(\"done sub system initialization\");");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void stop(){");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("super.stop();");
+      _builder.newLine();
+      {
+        boolean _hasVariableService_2 = this.dataConfigExt.hasVariableService(comp);
+        if (_hasVariableService_2) {
+          _builder.append("\t\t");
+          _builder.append("variableService.stop();");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_5 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_5) {
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("@Override");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public boolean hasGeneratedMSCInstrumentation() {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("return true;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("@Override");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void destroy() {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("DebuggingService.getInstance().addVisibleComment(\"begin sub system destruction\");");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("super.destroy();");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("DebuggingService.getInstance().addVisibleComment(\"done sub system destruction\");");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public IOptionalActorFactory getFactory(String optionalActorClass, String actorClass) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      final IntelligentSeparator else1 = new IntelligentSeparator("else ");
+      _builder.newLineIfNotEmpty();
+      {
+        for(final ActorClass oa : opt) {
+          _builder.append("\t\t");
+          _builder.append(else1, "\t\t");
+          _builder.append("if (optionalActorClass.equals(\"");
+          String _name_13 = oa.getName();
+          _builder.append(_name_13, "\t\t");
+          _builder.append("\")) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          final IntelligentSeparator else2 = new IntelligentSeparator("else ");
+          _builder.newLineIfNotEmpty();
+          {
+            final Function1<ActorClass, Boolean> _function_4 = (ActorClass s) -> {
+              boolean _isAbstract = s.isAbstract();
+              return Boolean.valueOf((!_isAbstract));
+            };
+            Iterable<ActorClass> _filter = IterableExtensions.<ActorClass>filter(this._roomExtensions.<ActorClass>union(root.getSubClasses(oa), oa), _function_4);
+            for(final ActorClass subcls : _filter) {
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append(else2, "\t\t\t");
+              _builder.append("if (\"");
+              String _name_14 = subcls.getName();
+              _builder.append(_name_14, "\t\t\t");
+              _builder.append("\".equals(actorClass)) {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("return new ");
+              String _javaFactoryName = this._javaExtensions.getJavaFactoryName(subcls);
+              _builder.append(_javaFactoryName, "\t\t\t\t");
+              _builder.append("();");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return null;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("};");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private String getThreadId(final PhysicalThread thread) {
+    String _upperCase = thread.getName().toUpperCase();
+    return ("THREAD_" + _upperCase);
+  }
+  
+  private void checkDataPorts(final SubSystemInstance comp) {
+    final HashSet<String> found = new HashSet<String>();
+    EList<ActorInstance> _allContainedInstances = comp.getAllContainedInstances();
+    for (final ActorInstance ai : _allContainedInstances) {
+      {
+        final int thread = ai.getThreadId();
+        EList<InterfaceItemInstance> _orderedIfItemInstances = ai.getOrderedIfItemInstances();
+        for (final InterfaceItemInstance pi : _orderedIfItemInstances) {
+          CommunicationType _commType = pi.getProtocol().getCommType();
+          boolean _equals = Objects.equal(_commType, CommunicationType.DATA_DRIVEN);
+          if (_equals) {
+            EList<InterfaceItemInstance> _peers = pi.getPeers();
+            for (final InterfaceItemInstance peer : _peers) {
+              {
+                EObject _eContainer = peer.eContainer();
+                final ActorInstance peer_ai = ((ActorInstance) _eContainer);
+                final int peer_thread = peer_ai.getThreadId();
+                if ((thread != peer_thread)) {
+                  final String path = pi.getPath();
+                  final String ppath = peer.getPath();
+                  String _xifexpression = null;
+                  int _compareTo = path.compareTo(ppath);
+                  boolean _lessThan = (_compareTo < 0);
+                  if (_lessThan) {
+                    _xifexpression = ((path + " and ") + ppath);
+                  } else {
+                    _xifexpression = ((ppath + " and ") + path);
+                  }
+                  final String pair = _xifexpression;
+                  boolean _contains = found.contains(pair);
+                  boolean _not = (!_contains);
+                  if (_not) {
+                    found.add(pair);
+                    this.diagnostician.error((pair + ": data ports placed on different threads (not supported yet)"), 
+                      pi.getInterfaceItem(), pi.getInterfaceItem().eContainingFeature());
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/OptionalActorFactoryGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/OptionalActorFactoryGen.java
new file mode 100644
index 000000000..0616e4b64
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/OptionalActorFactoryGen.java
@@ -0,0 +1,216 @@
+package org.eclipse.etrice.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import java.util.HashMap;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+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.Root;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredActorClass;
+import org.eclipse.etrice.core.genmodel.etricegen.WiredStructureClass;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.CommunicationType;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class OptionalActorFactoryGen {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  private JavaExtensions _javaExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  public void doGenerate(final Root root) {
+    final HashMap<ActorClass, WiredActorClass> ac2wired = new HashMap<ActorClass, WiredActorClass>();
+    final Function1<WiredStructureClass, Boolean> _function = (WiredStructureClass w) -> {
+      return Boolean.valueOf((w instanceof WiredActorClass));
+    };
+    final Consumer<WiredStructureClass> _function_1 = (WiredStructureClass w) -> {
+      ac2wired.put(((WiredActorClass) w).getActorClass(), ((WiredActorClass) w));
+    };
+    IterableExtensions.<WiredStructureClass>filter(root.getWiredInstances(), _function).forEach(_function_1);
+    final Function1<OptionalActorInstance, Boolean> _function_2 = (OptionalActorInstance cl) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(cl.getActorClass()));
+    };
+    Iterable<OptionalActorInstance> _filter = IterableExtensions.<OptionalActorInstance>filter(root.getOptionalInstances(), _function_2);
+    for (final OptionalActorInstance oi : _filter) {
+      {
+        final ActorClass ac = oi.getActorClass();
+        final WiredActorClass wired = ac2wired.get(ac);
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(ac);
+        String _path = this._roomExtensions.getPath(ac);
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(ac);
+        String _path_1 = this._roomExtensions.getPath(ac);
+        final String infopath = (_generationInfoPath + _path_1);
+        final String file = this._javaExtensions.getJavaFactoryFileName(ac);
+        this.fileIO.generateFile("generating ActorClass Interface implementation", path, infopath, file, this.generate(root, oi, wired));
+      }
+    }
+  }
+  
+  public CharSequence generate(final Root root, final OptionalActorInstance oi, final WiredActorClass wired) {
+    CharSequence _xblockexpression = null;
+    {
+      final ActorClass ac = oi.getActorClass();
+      final String clsname = this._javaExtensions.getJavaFactoryName(ac);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("package ");
+      String _package = this._roomExtensions.getPackage(ac);
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("import ");
+      String _package_1 = this._roomExtensions.getPackage(ac);
+      _builder.append(_package_1);
+      _builder.append(".");
+      String _name = ac.getName();
+      _builder.append(_name);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.OptionalActorInterfaceBase;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.IOptionalActorFactory;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.InterfaceItemBase;");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("public class ");
+      _builder.append(clsname);
+      _builder.append(" implements IOptionalActorFactory {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      String _name_1 = ac.getName();
+      _builder.append(_name_1, "\t");
+      _builder.append(" create(OptionalActorInterfaceBase ai, String name) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("// instantiate sub tree");
+      _builder.newLine();
+      _builder.append("\t\t");
+      String _name_2 = ac.getName();
+      _builder.append(_name_2, "\t\t");
+      _builder.append(" actor = new ");
+      String _name_3 = ac.getName();
+      _builder.append(_name_3, "\t\t");
+      _builder.append("(ai, name);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// wiring");
+      _builder.newLine();
+      {
+        final Function1<Port, Boolean> _function = (Port p) -> {
+          return Boolean.valueOf(this._roomHelpers.isExternal(p));
+        };
+        Iterable<Port> _filter = IterableExtensions.<Port>filter(this._roomHelpers.getAllEndPorts(ac), _function);
+        for(final Port port : _filter) {
+          _builder.append("\t\t");
+          String _xifexpression = null;
+          boolean _isDataDriven = this._roomHelpers.isDataDriven(port);
+          if (_isDataDriven) {
+            _xifexpression = "DataPortBase";
+          } else {
+            _xifexpression = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression, "\t\t");
+          _builder.append(".connect(ai, \"");
+          String _name_4 = port.getName();
+          _builder.append(_name_4, "\t\t");
+          _builder.append("\", name+\"/");
+          String _name_5 = port.getName();
+          _builder.append(_name_5, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<OpenBinding> _openBindings = wired.getOpenBindings();
+        for(final OpenBinding open : _openBindings) {
+          _builder.append("\t\t");
+          String _xifexpression_1 = null;
+          boolean _isDataDriven_1 = this._roomHelpers.isDataDriven(open.getPort());
+          if (_isDataDriven_1) {
+            _xifexpression_1 = "DataPortBase";
+          } else {
+            _xifexpression_1 = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression_1, "\t\t");
+          _builder.append(".connect(ai, \"");
+          String _name_6 = open.getPort().getName();
+          _builder.append(_name_6, "\t\t");
+          _builder.append("\", name+\"/");
+          String _join = IterableExtensions.join(open.getPath(), "/");
+          _builder.append(_join, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        EList<OpenServiceConnection> _requiredServices = wired.getRequiredServices();
+        for(final OpenServiceConnection req : _requiredServices) {
+          _builder.append("\t\t");
+          String _xifexpression_2 = null;
+          CommunicationType _commType = req.getProtocol().getCommType();
+          boolean _equals = Objects.equal(_commType, CommunicationType.DATA_DRIVEN);
+          if (_equals) {
+            _xifexpression_2 = "DataPortBase";
+          } else {
+            _xifexpression_2 = "InterfaceItemBase";
+          }
+          _builder.append(_xifexpression_2, "\t\t");
+          _builder.append(".connect(ai, \"");
+          String _fullyQualifiedName = this._roomExtensions.getFullyQualifiedName(req.getProtocol());
+          _builder.append(_fullyQualifiedName, "\t\t");
+          _builder.append("\", name+\"/");
+          String _join_1 = IterableExtensions.join(req.getPath(), "/");
+          _builder.append(_join_1, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t\t");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return actor;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.java
new file mode 100644
index 000000000..9dd91217b
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/ProtocolClassGen.java
@@ -0,0 +1,1030 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.room.CommunicationType;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageHandler;
+import org.eclipse.etrice.core.room.PortClass;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.base.IGeneratorFileIo;
+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.java.Main;
+import org.eclipse.etrice.generator.java.gen.DataClassGen;
+import org.eclipse.etrice.generator.java.gen.Initialization;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class ProtocolClassGen extends GenericProtocolClassGenerator {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private JavaExtensions _javaExtensions;
+  
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers _procedureHelpers;
+  
+  @Inject
+  @Extension
+  private Initialization _initialization;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  private DataClassGen _dataClassGen;
+  
+  @Inject
+  @Extension
+  private FileSystemHelpers _fileSystemHelpers;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void doGenerate(final Root root) {
+    final Function1<ProtocolClass, Boolean> _function = (ProtocolClass cl) -> {
+      return Boolean.valueOf(this._fileSystemHelpers.isValidGenerationLocation(cl));
+    };
+    Iterable<ProtocolClass> _filter = IterableExtensions.<ProtocolClass>filter(root.getProtocolClasses(), _function);
+    for (final ProtocolClass pc : _filter) {
+      {
+        String _generationTargetPath = this._roomExtensions.getGenerationTargetPath(pc);
+        String _path = this._roomExtensions.getPath(pc);
+        final String path = (_generationTargetPath + _path);
+        String _generationInfoPath = this._roomExtensions.getGenerationInfoPath(pc);
+        String _path_1 = this._roomExtensions.getPath(pc);
+        final String infopath = (_generationInfoPath + _path_1);
+        final String file = this._javaExtensions.getJavaFileName(pc);
+        CharSequence _switchResult = null;
+        CommunicationType _commType = pc.getCommType();
+        if (_commType != null) {
+          switch (_commType) {
+            case EVENT_DRIVEN:
+              _switchResult = this.generate(root, pc);
+              break;
+            case DATA_DRIVEN:
+              _switchResult = this.generateDataDriven(root, pc);
+              break;
+            case SYNCHRONOUS:
+              _switchResult = "";
+              break;
+            default:
+              break;
+          }
+        }
+        final CharSequence contents = _switchResult;
+        boolean _isEmpty = contents.toString().isEmpty();
+        if (_isEmpty) {
+          this.logger.logError("synchronous protocols not supported yet", pc);
+        } else {
+          this.fileIO.generateFile("generating ProtocolClass implementation", path, infopath, file, contents);
+        }
+      }
+    }
+  }
+  
+  public CharSequence generate(final Root root, final ProtocolClass pc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("package ");
+    String _package = this._roomExtensions.getPackage(pc);
+    _builder.append(_package);
+    _builder.append(";");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.messaging.Message;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.EventMessage;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.EventWithDataMessage;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.IInterfaceItemOwner;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.InterfaceItemBase;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.PortBase;");
+    _builder.newLine();
+    _builder.append("import org.eclipse.etrice.runtime.java.modelbase.ReplicatedPortBase;");
+    _builder.newLine();
+    {
+      boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+      if (_isGenerateMSCInstrumentation) {
+        _builder.append("import org.eclipse.etrice.runtime.java.debugging.DebuggingService;");
+        _builder.newLine();
+      }
+    }
+    _builder.append("import static org.eclipse.etrice.runtime.java.etunit.EtUnit.*;");
+    _builder.newLine();
+    _builder.newLine();
+    CharSequence _userCode = this._procedureHelpers.userCode(pc, 1);
+    _builder.append(_userCode);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    EList<RoomModel> models = root.getReferencedModels(pc);
+    _builder.newLineIfNotEmpty();
+    {
+      for(final RoomModel model : models) {
+        _builder.append("import ");
+        String _name = model.getName();
+        _builder.append(_name);
+        _builder.append(".*;");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.newLine();
+    _builder.append("public class ");
+    String _name_1 = pc.getName();
+    _builder.append(_name_1);
+    _builder.append(" {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("// message IDs");
+    _builder.newLine();
+    _builder.append("\t");
+    String _genMessageIDs = this.genMessageIDs(pc);
+    _builder.append(_genMessageIDs, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _userCode_1 = this._procedureHelpers.userCode(pc, 2);
+    _builder.append(_userCode_1, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("private static String messageStrings[] = {\"MIN\", ");
+    {
+      List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+      for(final Message m : _allOutgoingMessages) {
+        _builder.append("\"");
+        String _name_2 = m.getName();
+        _builder.append(_name_2, "\t");
+        _builder.append("\",");
+      }
+    }
+    _builder.append(" ");
+    {
+      List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+      for(final Message m_1 : _allIncomingMessages) {
+        _builder.append("\"");
+        String _name_3 = m_1.getName();
+        _builder.append(_name_3, "\t");
+        _builder.append("\",");
+      }
+    }
+    _builder.append("\"MAX\"};");
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("public String getMessageString(int msg_id) {");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("if (msg_id<MSG_MIN || msg_id>MSG_MAX+1){");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("// id out of range");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("return \"Message ID out of range\";");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("else{");
+    _builder.newLine();
+    _builder.append("\t\t\t");
+    _builder.append("return messageStrings[msg_id];");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _portClass = this.portClass(pc, false);
+    _builder.append(_portClass, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    CharSequence _portClass_1 = this.portClass(pc, true);
+    _builder.append(_portClass_1, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  public CharSequence portClass(final ProtocolClass pc, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      PortClass pclass = this._roomExtensions.getPortClass(pc, conj);
+      String portClassName = this._roomExtensions.getPortClassName(pc, conj);
+      String replPortClassName = this._roomExtensions.getPortClassName(pc, conj, true);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.newLine();
+      _builder.append("// port class");
+      _builder.newLine();
+      _builder.append("static public class ");
+      _builder.append(portClassName);
+      _builder.append(" extends PortBase {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _notEquals = (!Objects.equal(pclass, null));
+        if (_notEquals) {
+          _builder.append("\t");
+          CharSequence _userCode = this._procedureHelpers.userCode(pclass.getUserCode());
+          _builder.append(_userCode, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("// constructors");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(portClassName, "\t");
+      _builder.append("(IInterfaceItemOwner actor, String name, int localId) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("this(actor, name, localId, 0);");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(portClassName, "\t");
+      _builder.append("(IInterfaceItemOwner actor, String name, int localId, int idx) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("super(actor, name, localId, idx);");
+      _builder.newLine();
+      {
+        boolean _notEquals_1 = (!Objects.equal(pclass, null));
+        if (_notEquals_1) {
+          _builder.append("\t\t");
+          CharSequence _attributeInitialization = this._initialization.attributeInitialization(pclass.getAttributes(), pclass, true);
+          _builder.append(_attributeInitialization, "\t\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t\t");
+          _builder.append("DebuggingService.getInstance().addPortInstance(this);");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_1 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_1) {
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("public void destroy() {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("DebuggingService.getInstance().removePortInstance(this);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("super.destroy();");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void receive(Message m) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("if (!(m instanceof EventMessage))");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("return;");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("EventMessage msg = (EventMessage) m;");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("if (0 < msg.getEvtId() && msg.getEvtId() < MSG_MAX) {");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation_2 = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation_2) {
+          _builder.append("\t\t\t");
+          _builder.append("DebuggingService.getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), messageStrings[msg.getEvtId()]);");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _handlesReceive = this._roomExtensions.handlesReceive(pc, conj);
+        if (_handlesReceive) {
+          _builder.append("\t\t\t");
+          _builder.append("switch (msg.getEvtId()) {");
+          _builder.newLine();
+          {
+            List<MessageHandler> _receiveHandlers = this._roomExtensions.getReceiveHandlers(pc, conj);
+            for(final MessageHandler hdlr : _receiveHandlers) {
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("case ");
+              String _codeName = this._roomExtensions.getCodeName(hdlr.getMsg());
+              _builder.append(_codeName, "\t\t\t\t");
+              _builder.append(":");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("{");
+              _builder.newLine();
+              {
+                EList<String> _lines = hdlr.getDetailCode().getLines();
+                for(final String command : _lines) {
+                  _builder.append("\t\t\t");
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append(command, "\t\t\t\t\t");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t\t\t");
+              _builder.append("\t");
+              _builder.append("break;");
+              _builder.newLine();
+            }
+          }
+          _builder.append("\t\t\t");
+          _builder.append("\t");
+          _builder.append("default:");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t\t\t");
+      _builder.append("if (msg instanceof EventWithDataMessage)");
+      _builder.newLine();
+      _builder.append("\t\t\t\t");
+      _builder.append("getActor().receiveEvent(this, msg.getEvtId(), ((EventWithDataMessage)msg).getData());");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("else");
+      _builder.newLine();
+      _builder.append("\t\t\t\t");
+      _builder.append("getActor().receiveEvent(this, msg.getEvtId(), null);");
+      _builder.newLine();
+      {
+        boolean _handlesReceive_1 = this._roomExtensions.handlesReceive(pc, conj);
+        if (_handlesReceive_1) {
+          _builder.append("\t\t\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        boolean _notEquals_2 = (!Objects.equal(pclass, null));
+        if (_notEquals_2) {
+          _builder.append("\t");
+          CharSequence _attributes = this._procedureHelpers.attributes(pclass.getAttributes());
+          _builder.append(_attributes, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _attributeSettersGettersImplementation = this._procedureHelpers.attributeSettersGettersImplementation(pclass.getAttributes(), null);
+          _builder.append(_attributeSettersGettersImplementation, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _operationsImplementation = this._procedureHelpers.operationsImplementation(pclass.getOperations(), portClassName);
+          _builder.append(_operationsImplementation, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// sent messages");
+      _builder.newLine();
+      {
+        List<Message> _allMessages = this._roomHelpers.getAllMessages(pc, conj);
+        for(final Message m : _allMessages) {
+          _builder.append("\t");
+          CharSequence _sendMessage = this.sendMessage(m, conj);
+          _builder.append(_sendMessage, "\t");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("// replicated port class");
+      _builder.newLine();
+      _builder.append("static public class ");
+      _builder.append(replPortClassName);
+      _builder.append(" extends ReplicatedPortBase {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(replPortClassName, "\t");
+      _builder.append("(IInterfaceItemOwner actor, String name, int localId) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("super(actor, name, localId);");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public int getReplication() {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return getNInterfaceItems();");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public int getIndexOf(InterfaceItemBase ifitem){");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("return ifitem.getIdx();");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(portClassName, "\t");
+      _builder.append(" get(int idx) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("return (");
+      _builder.append(portClassName, "\t\t");
+      _builder.append(") getInterfaceItem(idx);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected InterfaceItemBase createInterfaceItem(IInterfaceItemOwner rcv, String name, int lid, int idx) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return new ");
+      _builder.append(portClassName, "\t\t");
+      _builder.append("(rcv, name, lid, idx);");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      {
+        if (conj) {
+          _builder.append("\t");
+          _builder.append("// incoming messages");
+          _builder.newLine();
+          {
+            List<Message> _allIncomingMessages = this._roomHelpers.getAllIncomingMessages(pc);
+            for(final Message m_1 : _allIncomingMessages) {
+              _builder.append("\t");
+              CharSequence _messageSignature = this.messageSignature(m_1);
+              _builder.append(_messageSignature, "\t");
+              _builder.append("{");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("for (InterfaceItemBase item : getItems()) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("((");
+              _builder.append(portClassName, "\t\t\t");
+              _builder.append(")item).");
+              CharSequence _messageCall = this.messageCall(m_1);
+              _builder.append(_messageCall, "\t\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        } else {
+          _builder.append("\t");
+          _builder.append("// outgoing messages");
+          _builder.newLine();
+          {
+            List<Message> _allOutgoingMessages = this._roomHelpers.getAllOutgoingMessages(pc);
+            for(final Message m_2 : _allOutgoingMessages) {
+              _builder.append("\t");
+              CharSequence _messageSignature_1 = this.messageSignature(m_2);
+              _builder.append(_messageSignature_1, "\t");
+              _builder.append("{");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("for (InterfaceItemBase item : getItems()) {");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("\t\t");
+              _builder.append("((");
+              _builder.append(portClassName, "\t\t\t");
+              _builder.append(")item).");
+              CharSequence _messageCall_1 = this.messageCall(m_2);
+              _builder.append(_messageCall_1, "\t\t\t");
+              _builder.append(";");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence messageSignature(final Message m) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _isPriv = m.isPriv();
+      if (_isPriv) {
+        _builder.append("private");
+      } else {
+        _builder.append("public");
+      }
+    }
+    _builder.append(" void ");
+    String _name = m.getName();
+    _builder.append(_name);
+    _builder.append("(");
+    {
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        String _typeName = this._typeHelpers.typeName(m.getData().getRefType().getType());
+        _builder.append(_typeName);
+        _builder.append(" ");
+        String _name_1 = m.getData().getName();
+        _builder.append(_name_1);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  public CharSequence messageSignatureExplicit(final Message m) {
+    CharSequence _xblockexpression = null;
+    {
+      DataType _type = m.getData().getRefType().getType();
+      DataClass dc = ((DataClass) _type);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("public void ");
+      String _name = m.getName();
+      _builder.append(_name);
+      _builder.append("(");
+      String _argList = this._dataClassGen.argList(dc);
+      _builder.append(_argList);
+      _builder.append(")");
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence messageCall(final Message m) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _name = m.getName();
+    _builder.append(_name);
+    _builder.append("(");
+    {
+      VarDecl _data = m.getData();
+      boolean _notEquals = (!Objects.equal(_data, null));
+      if (_notEquals) {
+        _builder.append(" ");
+        String _name_1 = m.getData().getName();
+        _builder.append(_name_1);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  public CharSequence sendMessage(final Message m, final boolean conj) {
+    CharSequence _xblockexpression = null;
+    {
+      String _xifexpression = null;
+      if (conj) {
+        _xifexpression = "IN";
+      } else {
+        _xifexpression = "OUT";
+      }
+      String dir = _xifexpression;
+      MessageHandler hdlr = this._roomExtensions.getSendHandler(m, conj);
+      StringConcatenation _builder = new StringConcatenation();
+      CharSequence _messageSignature = this.messageSignature(m);
+      _builder.append(_messageSignature);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      {
+        boolean _notEquals = (!Objects.equal(hdlr, null));
+        if (_notEquals) {
+          _builder.append("\t");
+          {
+            EList<String> _lines = hdlr.getDetailCode().getLines();
+            for(final String command : _lines) {
+              _builder.append("\t");
+              _builder.append(command, "\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        } else {
+          {
+            boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+            if (_isGenerateMSCInstrumentation) {
+              _builder.append("\t");
+              _builder.append("DebuggingService.getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(), messageStrings[");
+              _builder.append(dir, "\t");
+              _builder.append("_");
+              String _name = m.getName();
+              _builder.append(_name, "\t");
+              _builder.append("]);");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("\t");
+          _builder.append("if (getPeerAddress()!=null)");
+          _builder.newLine();
+          {
+            VarDecl _data = m.getData();
+            boolean _equals = Objects.equal(_data, null);
+            if (_equals) {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("getPeerMsgReceiver().receive(new EventMessage(getPeerAddress(), ");
+              _builder.append(dir, "\t\t");
+              _builder.append("_");
+              String _name_1 = m.getName();
+              _builder.append(_name_1, "\t\t");
+              _builder.append("));");
+              _builder.newLineIfNotEmpty();
+            } else {
+              _builder.append("\t");
+              _builder.append("\t");
+              _builder.append("getPeerMsgReceiver().receive(new EventWithDataMessage(getPeerAddress(), ");
+              _builder.append(dir, "\t\t");
+              _builder.append("_");
+              String _name_2 = m.getName();
+              _builder.append(_name_2, "\t\t");
+              _builder.append(", ");
+              String _name_3 = m.getData().getName();
+              _builder.append(_name_3, "\t\t");
+              {
+                if (((!m.getData().getRefType().isRef()) && (!this._typeHelpers.isEnumerationOrPrimitive(m.getData().getRefType().getType())))) {
+                  _builder.append(".deepCopy()");
+                }
+              }
+              _builder.append("));");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("}");
+      _builder.newLine();
+      {
+        if (((!Objects.equal(m.getData(), null)) && (m.getData().getRefType().getType() instanceof DataClass))) {
+          CharSequence _messageSignatureExplicit = this.messageSignatureExplicit(m);
+          _builder.append(_messageSignatureExplicit);
+          _builder.append(" {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          String _name_4 = m.getName();
+          _builder.append(_name_4, "\t");
+          _builder.append("(new ");
+          String _name_5 = m.getData().getRefType().getType().getName();
+          _builder.append(_name_5, "\t");
+          _builder.append("(");
+          DataType _type = m.getData().getRefType().getType();
+          String _paramList = this._dataClassGen.paramList(((DataClass) _type));
+          _builder.append(_paramList, "\t");
+          _builder.append("));");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence generateDataDriven(final Root root, final ProtocolClass pc) {
+    CharSequence _xblockexpression = null;
+    {
+      final Function1<Message, Boolean> _function = (Message m) -> {
+        VarDecl _data = m.getData();
+        return Boolean.valueOf((!Objects.equal(_data, null)));
+      };
+      final Iterable<Message> sentMsgs = IterableExtensions.<Message>filter(this._roomHelpers.getAllIncomingMessages(pc), _function);
+      final EList<RoomModel> models = root.getReferencedModels(pc);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("package ");
+      String _package = this._roomExtensions.getPackage(pc);
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.messaging.IRTObject;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.DataReceivePort;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.modelbase.DataSendPort;");
+      _builder.newLine();
+      _builder.append("import static org.eclipse.etrice.runtime.java.etunit.EtUnit.*;");
+      _builder.newLine();
+      _builder.newLine();
+      CharSequence _userCode = this._procedureHelpers.userCode(pc, 1);
+      _builder.append(_userCode);
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      {
+        for(final RoomModel model : models) {
+          _builder.append("import ");
+          String _name = model.getName();
+          _builder.append(_name);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("public class ");
+      String _name_1 = pc.getName();
+      _builder.append(_name_1);
+      _builder.append(" {");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      CharSequence _userCode_1 = this._procedureHelpers.userCode(pc, 2);
+      _builder.append(_userCode_1, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// send port holds data");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("static public class ");
+      String _portClassName = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName, "\t");
+      _builder.append(" extends DataSendPort {");
+      _builder.newLineIfNotEmpty();
+      {
+        for(final Message msg : sentMsgs) {
+          _builder.append("\t\t");
+          _builder.append("private ");
+          String _typeName = this._typeHelpers.typeName(msg.getData().getRefType().getType());
+          _builder.append(_typeName, "\t\t");
+          _builder.append(" ");
+          String _name_2 = msg.getName();
+          _builder.append(_name_2, "\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// constructor");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("public ");
+      String _portClassName_1 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_1, "\t\t");
+      _builder.append("(IRTObject parent, String name, int localId) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t\t");
+      _builder.append("super(parent, name, localId);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// getters and setters");
+      _builder.newLine();
+      {
+        for(final Message msg_1 : sentMsgs) {
+          _builder.append("\t\t");
+          _builder.append("public void ");
+          String _name_3 = msg_1.getName();
+          _builder.append(_name_3, "\t\t");
+          _builder.append("(");
+          String _typeName_1 = this._typeHelpers.typeName(msg_1.getData().getRefType().getType());
+          _builder.append(_typeName_1, "\t\t");
+          _builder.append(" ");
+          String _name_4 = msg_1.getName();
+          _builder.append(_name_4, "\t\t");
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("this.");
+          String _name_5 = msg_1.getName();
+          _builder.append(_name_5, "\t\t\t");
+          _builder.append(" = ");
+          String _name_6 = msg_1.getName();
+          _builder.append(_name_6, "\t\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("public ");
+          String _typeName_2 = this._typeHelpers.typeName(msg_1.getData().getRefType().getType());
+          _builder.append(_typeName_2, "\t\t");
+          _builder.append(" ");
+          String _name_7 = msg_1.getName();
+          _builder.append(_name_7, "\t\t");
+          _builder.append("() {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("return ");
+          String _name_8 = msg_1.getName();
+          _builder.append(_name_8, "\t\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// receive port accesses send port");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("static public class ");
+      String _portClassName_2 = this._roomExtensions.getPortClassName(pc, false);
+      _builder.append(_portClassName_2, "\t");
+      _builder.append(" extends DataReceivePort {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("private ");
+      String _portClassName_3 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_3, "\t\t");
+      _builder.append(" peer;");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// constructor");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("public ");
+      String _portClassName_4 = this._roomExtensions.getPortClassName(pc, false);
+      _builder.append(_portClassName_4, "\t\t");
+      _builder.append("(IRTObject parent, String name, int localId) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t\t");
+      _builder.append("super(parent, name, localId);");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("// getters");
+      _builder.newLine();
+      {
+        for(final Message msg_2 : sentMsgs) {
+          _builder.append("\t\t");
+          _builder.append("public ");
+          String _typeName_3 = this._typeHelpers.typeName(msg_2.getData().getRefType().getType());
+          _builder.append(_typeName_3, "\t\t");
+          _builder.append(" ");
+          String _name_9 = msg_2.getName();
+          _builder.append(_name_9, "\t\t");
+          _builder.append("() {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("if (peer==null)");
+          _builder.newLine();
+          _builder.append("\t\t");
+          _builder.append("\t\t");
+          _builder.append("return ");
+          String _defaultValue = this._javaExtensions.defaultValue(msg_2.getData().getRefType().getType());
+          _builder.append(_defaultValue, "\t\t\t\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("return peer.");
+          String _name_10 = msg_2.getName();
+          _builder.append(_name_10, "\t\t\t");
+          _builder.append("();");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("protected void connect(DataSendPort dataSendPort) {");
+      _builder.newLine();
+      _builder.append("\t\t\t");
+      _builder.append("if (dataSendPort instanceof ");
+      String _portClassName_5 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_5, "\t\t\t");
+      _builder.append(")");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t\t\t");
+      _builder.append("peer = (");
+      String _portClassName_6 = this._roomExtensions.getPortClassName(pc, true);
+      _builder.append(_portClassName_6, "\t\t\t\t");
+      _builder.append(")dataSendPort;");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/StateMachineGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/StateMachineGen.java
new file mode 100644
index 000000000..dd1bd481d
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/StateMachineGen.java
@@ -0,0 +1,171 @@
+/**
+ * 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.generator.java.gen;
+
+import com.google.inject.Singleton;
+import java.util.Comparator;
+import java.util.List;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
+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.Node;
+import org.eclipse.etrice.generator.generic.GenericStateMachineGenerator;
+import org.eclipse.etrice.generator.java.Main;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class StateMachineGen extends GenericStateMachineGenerator {
+  private static class NodeComparator implements Comparator<Node> {
+    @Override
+    public int compare(final Node o1, final Node o2) {
+      int _inheritanceLevel = o1.getInheritanceLevel();
+      int _inheritanceLevel_1 = o2.getInheritanceLevel();
+      boolean _equals = (_inheritanceLevel == _inheritanceLevel_1);
+      if (_equals) {
+        if ((FsmGenExtensions.isLeaf(o1) && FsmGenExtensions.isLeaf(o2))) {
+          return 0;
+        }
+        boolean _isLeaf = FsmGenExtensions.isLeaf(o1);
+        if (_isLeaf) {
+          return 1;
+        }
+        boolean _isLeaf_1 = FsmGenExtensions.isLeaf(o2);
+        if (_isLeaf_1) {
+          return (-1);
+        }
+        return 0;
+      } else {
+        return Integer.compare(o1.getInheritanceLevel(), o1.getInheritanceLevel());
+      }
+    }
+  }
+  
+  private final StateMachineGen.NodeComparator nodeComparator = new StateMachineGen.NodeComparator();
+  
+  /**
+   * @param generateImplementation NOT used
+   */
+  @Override
+  public CharSequence genExtra(final GraphContainer gc, final boolean generateImplementation) {
+    CharSequence _xblockexpression = null;
+    {
+      final List<Node> orderedStateNodes = IterableExtensions.<Node>sortWith(IteratorExtensions.<Node>toList(FsmGenExtensions.getAllStateNodes(gc.getGraph())), this.nodeComparator);
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        if ((Main.getSettings().isGenerateMSCInstrumentation() || Main.getSettings().isGenerateWithVerboseOutput())) {
+          _builder.append("// state names");
+          _builder.newLine();
+          _builder.append("protected static final String stateStrings[] = {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\"<no state>\",");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\"<top>\",");
+          _builder.newLine();
+          {
+            boolean _hasElements = false;
+            for(final Node node : orderedStateNodes) {
+              if (!_hasElements) {
+                _hasElements = true;
+              } else {
+                _builder.appendImmediate(",", "\t");
+              }
+              _builder.append("\t");
+              _builder.append("\"");
+              StateGraphNode _stateGraphNode = node.getStateGraphNode();
+              String _genStatePathName = this._codegenHelpers.getGenStatePathName(((State) _stateGraphNode));
+              _builder.append(_genStatePathName, "\t");
+              _builder.append("\"");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+          _builder.append("};");
+          _builder.newLine();
+          _builder.newLine();
+        }
+      }
+      _builder.append("// history");
+      _builder.newLine();
+      _builder.append("protected int history[] = {NO_STATE, NO_STATE");
+      {
+        for(final Node state : orderedStateNodes) {
+          _builder.append(", NO_STATE");
+        }
+      }
+      _builder.append("};");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("private void setState(int new_state) {");
+      _builder.newLine();
+      {
+        boolean _isGenerateMSCInstrumentation = Main.getSettings().isGenerateMSCInstrumentation();
+        if (_isGenerateMSCInstrumentation) {
+          _builder.append("\t");
+          _builder.append("DebuggingService.getInstance().addActorState(this,stateStrings[new_state]);");
+          _builder.newLine();
+        }
+      }
+      {
+        boolean _isGenerateWithVerboseOutput = Main.getSettings().isGenerateWithVerboseOutput();
+        if (_isGenerateWithVerboseOutput) {
+          _builder.append("\t");
+          _builder.append("if (stateStrings[new_state]!=\"Idle\") {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t");
+          _builder.append("System.out.println(\"state switch of \"+getInstancePath() + \": \"");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("\t\t\t");
+          _builder.append("+ stateStrings[this.state] + \" -> \" + stateStrings[new_state]);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("this.state = new_state;");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * if {@code -storeDataObj} is set then a call to {@code finalAction()} is generated
+   */
+  @Override
+  public CharSequence finalAction() {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _isGenerateStoreDataObj = Main.getSettings().isGenerateStoreDataObj();
+      if (_isGenerateStoreDataObj) {
+        _builder.append("finalAction();");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  public int getHistorySize(final ExpandedActorClass xpac) {
+    int _size = this._fSMHelpers.getAllBaseStates(xpac.getActorClass()).size();
+    return (_size + 2);
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/VariableServiceGen.java b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/VariableServiceGen.java
new file mode 100644
index 000000000..776b89346
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator.java/xtend-gen/org/eclipse/etrice/generator/java/gen/VariableServiceGen.java
@@ -0,0 +1,880 @@
+/**
+ * Copyright (c) 2012 Juergen Haug
+ * 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
+ */
+package org.eclipse.etrice.generator.java.gen;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.common.converter.TimeConverter;
+import org.eclipse.etrice.core.etmap.util.ETMapUtil;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.genmodel.etricegen.ActorInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+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.DataClass;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.base.IDataConfiguration;
+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.generator.generic.TypeHelpers;
+import org.eclipse.etrice.generator.java.gen.JavaExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@Singleton
+@SuppressWarnings("all")
+public class VariableServiceGen {
+  @Inject
+  private IGeneratorFileIo fileIO;
+  
+  @Inject
+  @Extension
+  private JavaExtensions stdExt;
+  
+  @Inject
+  @Extension
+  private RoomExtensions roomExt;
+  
+  @Inject
+  private IDataConfiguration configExt;
+  
+  @Inject
+  @Extension
+  private ProcedureHelpers helpers;
+  
+  @Inject
+  @Extension
+  private TypeHelpers _typeHelpers;
+  
+  @Inject
+  @Extension
+  private RoomHelpers _roomHelpers;
+  
+  public void doGenerate(final Root root, final SubSystemInstance ssi) {
+    final NodeRef nr = ETMapUtil.getNodeRef(ssi);
+    final String clsname = this.stdExt.getJavaClassName(nr, ssi);
+    String _generationTargetPath = this.roomExt.getGenerationTargetPath(ssi.getSubSystemClass());
+    String _path = this.roomExt.getPath(ssi.getSubSystemClass());
+    final String path = (_generationTargetPath + _path);
+    String _generationInfoPath = this.roomExt.getGenerationInfoPath(ssi.getSubSystemClass());
+    String _path_1 = this.roomExt.getPath(ssi.getSubSystemClass());
+    final String infopath = (_generationInfoPath + _path_1);
+    final String file = (clsname + "VariableService.java");
+    this.fileIO.generateFile("generating VariableService implementation", path, infopath, file, this.generate(root, ssi));
+  }
+  
+  private CharSequence generate(final Root root, final SubSystemInstance comp) {
+    CharSequence _xblockexpression = null;
+    {
+      final NodeRef nr = ETMapUtil.getNodeRef(comp);
+      final String clsname = this.stdExt.getJavaClassName(nr, comp);
+      final HashMap<ActorInstance, List<Attribute>> aisAttrMap = new HashMap<ActorInstance, List<Attribute>>();
+      final Consumer<ActorInstance> _function = (ActorInstance ai) -> {
+        boolean _isEmpty = this.configExt.getDynConfigReadAttributes(ai).isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          aisAttrMap.put(ai, this.configExt.getDynConfigReadAttributes(ai));
+        }
+      };
+      comp.getAllContainedInstances().forEach(_function);
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.newLine();
+      _builder.append("package ");
+      String _package = this.roomExt.getPackage(comp.getSubSystemClass());
+      _builder.append(_package);
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.newLine();
+      _builder.append("import java.util.Arrays;");
+      _builder.newLine();
+      _builder.append("import java.util.HashMap;");
+      _builder.newLine();
+      _builder.append("import java.util.Map;");
+      _builder.newLine();
+      _builder.append("import org.eclipse.etrice.runtime.java.config.AbstractVariableService;");
+      _builder.newLine();
+      String _userCode1 = this.configExt.getUserCode1(comp);
+      _builder.append(_userCode1);
+      _builder.newLineIfNotEmpty();
+      {
+        HashSet<RoomModel> _roomModels = this.getRoomModels(aisAttrMap.keySet());
+        for(final RoomModel model : _roomModels) {
+          _builder.append("import ");
+          String _name = model.getName();
+          _builder.append(_name);
+          _builder.append(".*;");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("public class ");
+      _builder.append(clsname);
+      _builder.append("VariableService extends AbstractVariableService{");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("private ");
+      _builder.append(clsname, "\t");
+      _builder.append(" subSystem;");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// Actor instances");
+      _builder.newLine();
+      {
+        Set<ActorInstance> _keySet = aisAttrMap.keySet();
+        for(final ActorInstance ai : _keySet) {
+          _builder.append("\t");
+          _builder.append("private ");
+          String _name_1 = ai.getActorClass().getName();
+          _builder.append(_name_1, "\t");
+          _builder.append(" ");
+          CharSequence _varName = this.getVarName(ai);
+          _builder.append(_varName, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public ");
+      _builder.append(clsname, "\t");
+      _builder.append("VariableService(");
+      _builder.append(clsname, "\t");
+      _builder.append(" subSystem) {");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("super(");
+      String _userCode2 = this.configExt.getUserCode2(comp);
+      _builder.append(_userCode2, "\t\t");
+      _builder.append(");");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t\t");
+      _builder.append("this.subSystem = subSystem;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected void initInstances(){");
+      _builder.newLine();
+      {
+        Set<ActorInstance> _keySet_1 = aisAttrMap.keySet();
+        for(final ActorInstance ai_1 : _keySet_1) {
+          _builder.append("\t\t");
+          CharSequence _varName_1 = this.getVarName(ai_1);
+          _builder.append(_varName_1, "\t\t");
+          _builder.append(" = (");
+          String _name_2 = ai_1.getActorClass().getName();
+          _builder.append(_name_2, "\t\t");
+          _builder.append(")subSystem.getInstance(\"");
+          String _path = ai_1.getPath();
+          _builder.append(_path, "\t\t");
+          _builder.append("\");");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected void setAttributeValues(Map<String, Object> values) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("Object object;");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("String id = null;");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.newLine();
+      {
+        Set<ActorInstance> _keySet_2 = aisAttrMap.keySet();
+        for(final ActorInstance ai_2 : _keySet_2) {
+          {
+            List<Attribute> _get = aisAttrMap.get(ai_2);
+            for(final Attribute a : _get) {
+              _builder.append("\t\t");
+              _builder.append("try{");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("boolean changed = false;");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              CharSequence _genSetAttributeValues1 = this.genSetAttributeValues1(this.roomExt.<Attribute>union(new ArrayList<Attribute>(), a), ai_2);
+              _builder.append(_genSetAttributeValues1, "\t\t\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("if(changed)");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t\t");
+              _builder.append("synchronized(");
+              CharSequence _varName_2 = this.getVarName(ai_2);
+              _builder.append(_varName_2, "\t\t\t\t");
+              _builder.append(".");
+              String _name_3 = a.getName();
+              String _plus = (_name_3 + "Lock");
+              CharSequence _invokeGetter = this.helpers.invokeGetter(_plus, null);
+              _builder.append(_invokeGetter, "\t\t\t\t");
+              _builder.append("){");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t\t\t");
+              _builder.append("if(");
+              CharSequence _varName_3 = this.getVarName(ai_2);
+              _builder.append(_varName_3, "\t\t\t\t\t");
+              _builder.append(".");
+              String _name_4 = a.getName();
+              String _plus_1 = (_name_4 + "Lock");
+              CharSequence _invokeGetter_1 = this.helpers.invokeGetter(_plus_1, null);
+              _builder.append(_invokeGetter_1, "\t\t\t\t\t");
+              _builder.append(".isUpdate()){");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t\t\t\t");
+              CharSequence _genSetAttributeValues2 = this.genSetAttributeValues2(this.roomExt.<Attribute>union(new ArrayList<Attribute>(), a), ai_2);
+              _builder.append(_genSetAttributeValues2, "\t\t\t\t\t\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t\t");
+              _builder.append("\t\t\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("}catch(IllegalArgumentException e){");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("\t");
+              _builder.append("error(id, e);");
+              _builder.newLine();
+              _builder.append("\t\t");
+              _builder.append("}");
+              _builder.newLine();
+            }
+          }
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected Map<String, Object> getAttributeValues(){");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("Map<String, Object> values = new HashMap<String, Object>();");
+      _builder.newLine();
+      {
+        Set<ActorInstance> _keySet_3 = aisAttrMap.keySet();
+        for(final ActorInstance ai_3 : _keySet_3) {
+          {
+            List<Attribute> _get_1 = aisAttrMap.get(ai_3);
+            for(final Attribute a_1 : _get_1) {
+              _builder.append("\t\t");
+              CharSequence _genGetAttributeValues = this.genGetAttributeValues(this.roomExt.<Attribute>union(new ArrayList<Attribute>(), a_1), ai_3);
+              _builder.append(_genGetAttributeValues, "\t\t");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _builder.append("\t\t");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return values;");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("public void writeDataClass(String id, Object dcObject, Map<String, Object> writeMap) {");
+      _builder.newLine();
+      _builder.append("\t\t");
+      HashSet<DataClass> dataClasses = this.getDynConfigDataClasses(aisAttrMap.keySet());
+      _builder.newLineIfNotEmpty();
+      {
+        for(final DataClass dc : dataClasses) {
+          _builder.append("\t\t");
+          _builder.append("if(dcObject.getClass().equals(");
+          String _typeName = this._typeHelpers.typeName(dc);
+          _builder.append(_typeName, "\t\t");
+          _builder.append(".class))");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t\t");
+          _builder.append("\t");
+          _builder.append("writeDataClass(id, (");
+          String _typeName_1 = this._typeHelpers.typeName(dc);
+          _builder.append(_typeName_1, "\t\t\t");
+          _builder.append(") dcObject, writeTasks);");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("// DataClasses write operations");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      {
+        HashSet<DataClass> _allDataClasses = this.getAllDataClasses(dataClasses);
+        for(final DataClass dc_1 : _allDataClasses) {
+          _builder.append("\t");
+          _builder.append("private void writeDataClass(String id, ");
+          String _typeName_2 = this._typeHelpers.typeName(dc_1);
+          _builder.append(_typeName_2, "\t");
+          _builder.append(" object, Map<String, Object> map){");
+          _builder.newLineIfNotEmpty();
+          {
+            List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dc_1);
+            for(final Attribute a_2 : _allAttributes) {
+              {
+                boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(a_2.getType().getType());
+                if (_isEnumerationOrPrimitive) {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("map.put(id+\"/");
+                  String _name_5 = a_2.getName();
+                  _builder.append(_name_5, "\t\t");
+                  _builder.append("\", ");
+                  {
+                    int _size = a_2.getSize();
+                    boolean _greaterThan = (_size > 0);
+                    if (_greaterThan) {
+                      _builder.append("toObjectArray(");
+                    }
+                  }
+                  _builder.append("object.");
+                  CharSequence _invokeGetter_2 = this.helpers.invokeGetter(a_2.getName(), null);
+                  _builder.append(_invokeGetter_2, "\t\t");
+                  {
+                    int _size_1 = a_2.getSize();
+                    boolean _greaterThan_1 = (_size_1 > 0);
+                    if (_greaterThan_1) {
+                      _builder.append(")");
+                    }
+                  }
+                  _builder.append(");");
+                  _builder.newLineIfNotEmpty();
+                } else {
+                  _builder.append("\t");
+                  _builder.append("\t");
+                  _builder.append("writeDataClass(id+\"/");
+                  String _name_6 = a_2.getName();
+                  _builder.append(_name_6, "\t\t");
+                  _builder.append("\", object.");
+                  CharSequence _invokeGetter_3 = this.helpers.invokeGetter(a_2.getName(), null);
+                  _builder.append(_invokeGetter_3, "\t\t");
+                  _builder.append(", map);");
+                  _builder.newLineIfNotEmpty();
+                }
+              }
+            }
+          }
+          _builder.append("\t");
+          _builder.append("}");
+          _builder.newLine();
+        }
+      }
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("@Override");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.append("protected int getPollingTimerUser(){");
+      _builder.newLine();
+      _builder.append("\t\t");
+      _builder.append("return ");
+      long _split = TimeConverter.split(this.configExt.getPollingTimerUser(comp), TimeConverter.MILLI_SEC, true);
+      _builder.append(_split, "\t\t");
+      _builder.append(";");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      _builder.append("}");
+      _builder.newLine();
+      _builder.append("\t");
+      _builder.newLine();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genMinMaxCheck(final List<Attribute> path, final ActorClass ac) {
+    CharSequence _xblockexpression = null;
+    {
+      Attribute a = IterableExtensions.<Attribute>last(path);
+      String aVarName = this.toAbsolutePath(path, "_");
+      String _attrClassConfigMinValue = this.configExt.getAttrClassConfigMinValue(ac, path);
+      boolean min = (!Objects.equal(_attrClassConfigMinValue, null));
+      String _attrClassConfigMaxValue = this.configExt.getAttrClassConfigMaxValue(ac, path);
+      boolean max = (!Objects.equal(_attrClassConfigMaxValue, null));
+      CharSequence _xifexpression = null;
+      if ((min || max)) {
+        StringConcatenation _builder = new StringConcatenation();
+        {
+          int _size = a.getSize();
+          boolean _greaterThan = (_size > 0);
+          if (_greaterThan) {
+            _builder.append("for(");
+            String _typeName = this._typeHelpers.typeName(a.getType().getType());
+            _builder.append(_typeName);
+            _builder.append(" e : ");
+            _builder.append(aVarName);
+            _builder.append(")");
+            _builder.newLineIfNotEmpty();
+            _builder.append("\t");
+          }
+        }
+        _builder.append("checkMinMax(");
+        {
+          int _size_1 = a.getSize();
+          boolean _greaterThan_1 = (_size_1 > 0);
+          if (_greaterThan_1) {
+            _builder.append("e");
+          } else {
+            _builder.append(aVarName);
+          }
+        }
+        _builder.append(", ");
+        {
+          if (min) {
+            String _name = ac.getName();
+            _builder.append(_name);
+            _builder.append(".MIN");
+            _builder.append(aVarName);
+          } else {
+            _builder.append("null");
+          }
+        }
+        _builder.append(", ");
+        {
+          if (max) {
+            String _name_1 = ac.getName();
+            _builder.append(_name_1);
+            _builder.append(".MAX");
+            _builder.append(aVarName);
+          } else {
+            _builder.append("null");
+          }
+        }
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _xifexpression = _builder;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  private HashSet<DataClass> getDynConfigDataClasses(final Iterable<ActorInstance> ais) {
+    final HashSet<DataClass> result = new HashSet<DataClass>();
+    final Consumer<ActorInstance> _function = (ActorInstance ai) -> {
+      final Consumer<Attribute> _function_1 = (Attribute a) -> {
+        boolean _isDataClass = this._typeHelpers.isDataClass(a.getType().getType());
+        if (_isDataClass) {
+          DataType _type = a.getType().getType();
+          result.add(((DataClass) _type));
+        }
+      };
+      this.configExt.getDynConfigReadAttributes(ai).forEach(_function_1);
+    };
+    ais.forEach(_function);
+    return result;
+  }
+  
+  private HashSet<DataClass> getAllDataClasses(final Iterable<DataClass> dcs) {
+    final HashSet<DataClass> result = new HashSet<DataClass>();
+    Iterables.<DataClass>addAll(result, dcs);
+    final LinkedList<DataClass> visit = new LinkedList<DataClass>();
+    Iterables.<DataClass>addAll(visit, dcs);
+    while ((!visit.isEmpty())) {
+      {
+        DataClass dc = visit.pop();
+        final Consumer<Attribute> _function = (Attribute a) -> {
+          boolean _isDataClass = this._typeHelpers.isDataClass(a.getType().getType());
+          if (_isDataClass) {
+            DataType _type = a.getType().getType();
+            visit.add(((DataClass) _type));
+          }
+        };
+        this._roomHelpers.getAllAttributes(dc).forEach(_function);
+      }
+    }
+    return result;
+  }
+  
+  private HashSet<RoomModel> getRoomModels(final Collection<ActorInstance> ais) {
+    final HashSet<RoomModel> models = new HashSet<RoomModel>();
+    final Consumer<ActorInstance> _function = (ActorInstance ai) -> {
+      EObject _eContainer = ai.getActorClass().eContainer();
+      models.add(((RoomModel) _eContainer));
+    };
+    ais.forEach(_function);
+    return models;
+  }
+  
+  private String toAbsolutePath(final List<Attribute> path, final String pathDelim) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      for(final Attribute p : path) {
+        _builder.append(pathDelim);
+        String _name = p.getName();
+        _builder.append(_name);
+      }
+    }
+    return _builder.toString();
+  }
+  
+  private CharSequence getVarName(final ActorInstance ai) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      Iterable<String> _drop = IterableExtensions.<String>drop(((Iterable<String>)Conversions.doWrapArray(ai.getPath().split("/"))), 2);
+      boolean _hasElements = false;
+      for(final String p : _drop) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate("_", "");
+        }
+        _builder.append(p);
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence genGetAttributeValues(final List<Attribute> path, final ActorInstance ai) {
+    CharSequence _xblockexpression = null;
+    {
+      final Attribute a = IterableExtensions.<Attribute>last(path);
+      CharSequence _xifexpression = null;
+      boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(a.getType().getType());
+      if (_isEnumerationOrPrimitive) {
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("values.put(\"");
+        String _path = ai.getPath();
+        _builder.append(_path);
+        String _absolutePath = this.toAbsolutePath(path, "/");
+        _builder.append(_absolutePath);
+        _builder.append("\", ");
+        {
+          int _size = a.getSize();
+          boolean _greaterThan = (_size > 0);
+          if (_greaterThan) {
+            _builder.append("toObjectArray(");
+          }
+        }
+        CharSequence _varName = this.getVarName(ai);
+        _builder.append(_varName);
+        _builder.append(".");
+        CharSequence _invokeGetters = this.helpers.invokeGetters(path, null);
+        _builder.append(_invokeGetters);
+        {
+          int _size_1 = a.getSize();
+          boolean _greaterThan_1 = (_size_1 > 0);
+          if (_greaterThan_1) {
+            _builder.append(")");
+          }
+        }
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _xifexpression = _builder;
+      } else {
+        CharSequence _xifexpression_1 = null;
+        boolean _isDataClass = this._typeHelpers.isDataClass(a.getType().getType());
+        if (_isDataClass) {
+          CharSequence _xblockexpression_1 = null;
+          {
+            DataType _type = a.getType().getType();
+            DataClass dataClass = ((DataClass) _type);
+            StringConcatenation _builder_1 = new StringConcatenation();
+            {
+              List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dataClass);
+              for(final Attribute at : _allAttributes) {
+                CharSequence _genGetAttributeValues = this.genGetAttributeValues(this.roomExt.<Attribute>union(path, at), ai);
+                _builder_1.append(_genGetAttributeValues);
+                _builder_1.newLineIfNotEmpty();
+              }
+            }
+            _xblockexpression_1 = _builder_1;
+          }
+          _xifexpression_1 = _xblockexpression_1;
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genSetAttributeValues1(final List<Attribute> path, final ActorInstance ai) {
+    CharSequence _xblockexpression = null;
+    {
+      Attribute a = IterableExtensions.<Attribute>last(path);
+      String aVarName = this.toAbsolutePath(path, "_");
+      CharSequence _xifexpression = null;
+      boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(a.getType().getType());
+      if (_isEnumerationOrPrimitive) {
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("id = \"");
+        String _path = ai.getPath();
+        _builder.append(_path);
+        String _absolutePath = this.toAbsolutePath(path, "/");
+        _builder.append(_absolutePath);
+        _builder.append("\";");
+        _builder.newLineIfNotEmpty();
+        {
+          int _size = a.getSize();
+          boolean _equals = (_size == 0);
+          if (_equals) {
+            String _wrapper = this.stdExt.toWrapper(this._typeHelpers.typeName(a.getType().getType()));
+            _builder.append(_wrapper);
+          } else {
+            String _typeName = this._typeHelpers.typeName(a.getType().getType());
+            _builder.append(_typeName);
+            _builder.append("[]");
+          }
+        }
+        _builder.append(" ");
+        _builder.append(aVarName);
+        _builder.append(" = null;");
+        _builder.newLineIfNotEmpty();
+        _builder.append("object = values.get(id);");
+        _builder.newLine();
+        _builder.append("if(object != null){");
+        _builder.newLine();
+        _builder.append("\t");
+        _builder.append(aVarName, "\t");
+        _builder.append(" = ensure");
+        String _firstUpper = StringExtensions.toFirstUpper(this._typeHelpers.typeName(a.getType().getType()));
+        _builder.append(_firstUpper, "\t");
+        {
+          int _size_1 = a.getSize();
+          boolean _greaterThan = (_size_1 > 0);
+          if (_greaterThan) {
+            _builder.append("Array");
+          }
+        }
+        _builder.append("(object");
+        {
+          int _size_2 = a.getSize();
+          boolean _greaterThan_1 = (_size_2 > 0);
+          if (_greaterThan_1) {
+            _builder.append(", ");
+            int _size_3 = a.getSize();
+            _builder.append(_size_3, "\t");
+          }
+        }
+        _builder.append(");");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        CharSequence _genMinMaxCheck = this.genMinMaxCheck(path, ai.getActorClass());
+        _builder.append(_genMinMaxCheck, "\t");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("if(!");
+        {
+          int _size_4 = a.getSize();
+          boolean _equals_1 = (_size_4 == 0);
+          if (_equals_1) {
+            _builder.append(aVarName, "\t");
+            _builder.append(".equals(");
+          } else {
+            _builder.append("Arrays.equals(");
+            _builder.append(aVarName, "\t");
+            _builder.append(", ");
+          }
+        }
+        _builder.append("(");
+        {
+          int _size_5 = a.getSize();
+          boolean _equals_2 = (_size_5 == 0);
+          if (_equals_2) {
+            String _wrapper_1 = this.stdExt.toWrapper(this._typeHelpers.typeName(a.getType().getType()));
+            _builder.append(_wrapper_1, "\t");
+          } else {
+            String _typeName_1 = this._typeHelpers.typeName(a.getType().getType());
+            _builder.append(_typeName_1, "\t");
+            _builder.append("[]");
+          }
+        }
+        _builder.append(")getDiffMap().get(id)))");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t\t");
+        _builder.append("changed = true;");
+        _builder.newLine();
+        _builder.append("} else");
+        _builder.newLine();
+        _builder.append("\t");
+        _builder.append("warning(id, \"is missing\");");
+        _builder.newLine();
+        _xifexpression = _builder;
+      } else {
+        CharSequence _xifexpression_1 = null;
+        boolean _isDataClass = this._typeHelpers.isDataClass(a.getType().getType());
+        if (_isDataClass) {
+          CharSequence _xblockexpression_1 = null;
+          {
+            DataType _type = a.getType().getType();
+            DataClass dataClass = ((DataClass) _type);
+            StringConcatenation _builder_1 = new StringConcatenation();
+            {
+              List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dataClass);
+              for(final Attribute at : _allAttributes) {
+                CharSequence _genSetAttributeValues1 = this.genSetAttributeValues1(this.roomExt.<Attribute>union(path, at), ai);
+                _builder_1.append(_genSetAttributeValues1);
+                _builder_1.newLineIfNotEmpty();
+              }
+            }
+            _xblockexpression_1 = _builder_1;
+          }
+          _xifexpression_1 = _xblockexpression_1;
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  private CharSequence genSetAttributeValues2(final List<Attribute> path, final ActorInstance ai) {
+    CharSequence _xblockexpression = null;
+    {
+      Attribute a = IterableExtensions.<Attribute>last(path);
+      String aVarName = this.toAbsolutePath(path, "_");
+      CharSequence _xifexpression = null;
+      boolean _isEnumerationOrPrimitive = this._typeHelpers.isEnumerationOrPrimitive(a.getType().getType());
+      if (_isEnumerationOrPrimitive) {
+        CharSequence _xblockexpression_1 = null;
+        {
+          String _xifexpression_1 = null;
+          int _size = path.size();
+          boolean _greaterThan = (_size > 1);
+          if (_greaterThan) {
+            int _size_1 = path.size();
+            int _minus = (_size_1 - 1);
+            CharSequence _invokeGetters = this.helpers.invokeGetters(IterableExtensions.<Attribute>take(path, _minus), null);
+            _xifexpression_1 = (_invokeGetters + ".");
+          } else {
+            _xifexpression_1 = "";
+          }
+          final String getters = _xifexpression_1;
+          StringConcatenation _builder = new StringConcatenation();
+          _builder.append("if(");
+          _builder.append(aVarName);
+          _builder.append(" != null){");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _varName = this.getVarName(ai);
+          _builder.append(_varName, "\t");
+          _builder.append(".");
+          _builder.append(getters, "\t");
+          CharSequence _invokeSetter = this.helpers.invokeSetter(a.getName(), null, aVarName);
+          _builder.append(_invokeSetter, "\t");
+          _builder.append(";");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("getDiffMap().put(\"");
+          String _path = ai.getPath();
+          _builder.append(_path, "\t");
+          String _absolutePath = this.toAbsolutePath(path, "/");
+          _builder.append(_absolutePath, "\t");
+          _builder.append("\", ");
+          _builder.append(aVarName, "\t");
+          _builder.append(");");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _xblockexpression_1 = _builder;
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        CharSequence _xifexpression_1 = null;
+        boolean _isDataClass = this._typeHelpers.isDataClass(a.getType().getType());
+        if (_isDataClass) {
+          CharSequence _xblockexpression_2 = null;
+          {
+            DataType _type = a.getType().getType();
+            final DataClass dataClass = ((DataClass) _type);
+            StringConcatenation _builder = new StringConcatenation();
+            {
+              List<Attribute> _allAttributes = this._roomHelpers.getAllAttributes(dataClass);
+              for(final Attribute at : _allAttributes) {
+                CharSequence _genSetAttributeValues2 = this.genSetAttributeValues2(this.roomExt.<Attribute>union(path, at), ai);
+                _builder.append(_genSetAttributeValues2);
+                _builder.newLineIfNotEmpty();
+              }
+            }
+            _xblockexpression_2 = _builder;
+          }
+          _xifexpression_1 = _xblockexpression_2;
+        }
+        _xifexpression = _xifexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+}
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 fcd4bff1c..6ce529d85 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;
@@ -584,7 +585,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/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/ModelLoader.java b/plugins/org.eclipse.etrice.generator/src/org/eclipse/etrice/generator/base/ModelLoader.java
index 3794a8562..638e9c71c 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;
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 3f65bc576..32dad3404 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
@@ -15,14 +15,13 @@ package org.eclipse.etrice.generator.generic
 import com.google.inject.Inject
 import com.google.inject.Singleton
 import java.io.File
+import java.util.Collection
 import java.util.HashSet
 import java.util.Set
 import org.eclipse.emf.ecore.resource.Resource
-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.xtext.generator.JavaIoFileSystemAccess
-import org.eclipse.etrice.generator.generic.RoomExtensions
-import java.util.Collection
 
 /**
  * A class that is used to recursively erase all folders receiving generated code
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..71c6100c3 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
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 2063e672a..8e67be9ad 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/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java
new file mode 100644
index 000000000..0d170c02c
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java
@@ -0,0 +1,434 @@
+/**
+ * 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.generator.generic;
+
+import com.google.inject.Inject;
+import org.eclipse.etrice.core.fsm.fSM.GuardedTransition;
+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.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+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.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;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+/**
+ * A target language independent generator of the state machine implementation
+ */
+@SuppressWarnings("all")
+public class GenericStateMachineGenerator extends AbstractStateMachineGenerator {
+  @Inject
+  @Extension
+  protected TriggerExtensions _triggerExtensions;
+  
+  @Inject
+  @Extension
+  protected FSMHelpers _fSMHelpers;
+  
+  /**
+   * generates the code of the whole state machine, consisting of constants + methods
+   * 
+   * @param xpmc the {@link ExpandedModelComponent}
+   * @return the generated code
+   */
+  public CharSequence genStateMachine(final GraphContainer gc) {
+    StringConcatenation _builder = new StringConcatenation();
+    CharSequence _genStateMachineConstants = this.genStateMachineConstants(gc);
+    _builder.append(_genStateMachineConstants);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    CharSequence _genStateMachineMethods = this.genStateMachineMethods(gc, true);
+    _builder.append(_genStateMachineMethods);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  /**
+   * generates the constants for the state machine
+   */
+  public CharSequence genStateMachineConstants(final GraphContainer gc) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/* state IDs */");
+    _builder.newLine();
+    String _genStateIdConstants = this.genStateIdConstants(gc);
+    _builder.append(_genStateIdConstants);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* transition chains */");
+    _builder.newLine();
+    String _genTransitionChainConstants = this.genTransitionChainConstants(gc);
+    _builder.append(_genTransitionChainConstants);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* triggers */");
+    _builder.newLine();
+    String _genTriggerConstants = this.genTriggerConstants(gc);
+    _builder.append(_genTriggerConstants);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  /**
+   * generates the methods for the state machine codes and state switching
+   * 
+   * @param xpmc the {@link ExpandedModelComponent}
+   * @param generateImplemenation or declaration only
+   * @return the generated code
+   */
+  public CharSequence genStateMachineMethods(final GraphContainer gc, final boolean generateImplementation) {
+    StringConcatenation _builder = new StringConcatenation();
+    CharSequence _genExtra = this.genExtra(gc, generateImplementation);
+    _builder.append(_genExtra);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* Entry and Exit Codes */");
+    _builder.newLine();
+    String _genEntryAndExitCodes = this.genEntryAndExitCodes(gc, generateImplementation);
+    _builder.append(_genEntryAndExitCodes);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* Action Codes */");
+    _builder.newLine();
+    String _genActionCodes = this.genActionCodes(gc, generateImplementation);
+    _builder.append(_genActionCodes);
+    _builder.newLineIfNotEmpty();
+    _builder.newLine();
+    _builder.append("/* State Switch Methods */");
+    _builder.newLine();
+    String _genStateSwitchMethods = this.genStateSwitchMethods(gc, generateImplementation);
+    _builder.append(_genStateSwitchMethods);
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  /**
+   * generate a transition guard if applicable
+   * 
+   * @param tt a {@link TriggeredTransition}
+   * @param trigger a trigger string
+   * @param xpmc an expanded actor class
+   * @return the generated code
+   */
+  @Override
+  public String genTriggeredTransitionGuard(final Link tt, final String trigger, final GraphContainer gc) {
+    String _xblockexpression = null;
+    {
+      TransitionBase _transition = tt.getTransition();
+      final Function1<Trigger, Boolean> _function = (Trigger trig) -> {
+        return Boolean.valueOf(this._triggerExtensions.isMatching(trig, trigger));
+      };
+      final Trigger tr = IterableExtensions.<Trigger>findFirst(((TriggeredTransition) _transition).getTriggers(), _function);
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _hasGuard = this._fSMHelpers.hasGuard(tr);
+        if (_hasGuard) {
+          _builder.append("if (");
+          String _translatedCode = this.translator.getTranslatedCode(tr.getGuard().getGuard());
+          _builder.append(_translatedCode);
+          _builder.append(")");
+          _builder.newLineIfNotEmpty();
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String genGuardedTransitionGuard(final Link link, final String trigger, final GraphContainer gc) {
+    StringConcatenation _builder = new StringConcatenation();
+    TransitionBase _transition = link.getTransition();
+    String _translatedCode = this.translator.getTranslatedCode(((GuardedTransition) _transition).getGuard());
+    _builder.append(_translatedCode);
+    _builder.newLineIfNotEmpty();
+    return _builder.toString();
+  }
+  
+  @Override
+  public String genActionCodeMethod(final GraphContainer gc, final Link link, final boolean generateImplementation) {
+    String _xblockexpression = null;
+    {
+      boolean hasArgs = ((!link.getChainHeads().isEmpty()) && IterableExtensions.<Link>forall(link.getChainHeads(), ((Function1<Link, Boolean>) (Link it) -> {
+        return Boolean.valueOf(((it.getTransition() instanceof NonInitialTransition) && (!(it.getTransition() instanceof GuardedTransition))));
+      })));
+      final String opScope = this.langExt.operationScope(this.getClassName(gc), false);
+      String _xifexpression = null;
+      boolean _usesInheritance = this.langExt.usesInheritance();
+      if (_usesInheritance) {
+        _xifexpression = opScope;
+      } else {
+        _xifexpression = "";
+      }
+      final String opScopePriv = _xifexpression;
+      String _pointerLiteral = this.langExt.pointerLiteral();
+      final String ifItemPtr = ("InterfaceItemBase" + _pointerLiteral);
+      String _xifexpression_1 = null;
+      boolean _usesPointers = this.langExt.usesPointers();
+      if (_usesPointers) {
+        _xifexpression_1 = ("const " + ifItemPtr);
+      } else {
+        _xifexpression_1 = ifItemPtr;
+      }
+      final String constIfItemPtr = _xifexpression_1;
+      String _xifexpression_2 = null;
+      if (generateImplementation) {
+        StringConcatenation _builder = new StringConcatenation();
+        String _accessLevelProtected = this.langExt.accessLevelProtected();
+        _builder.append(_accessLevelProtected);
+        _builder.append("void ");
+        _builder.append(opScopePriv);
+        String _actionCodeOperationName = this._codegenHelpers.getActionCodeOperationName(link.getTransition());
+        _builder.append(_actionCodeOperationName);
+        _builder.append("(");
+        String _selfPointer = this.langExt.selfPointer(this.getClassName(gc), hasArgs);
+        _builder.append(_selfPointer);
+        {
+          if (hasArgs) {
+            _builder.append(constIfItemPtr);
+            _builder.append(" ifitem");
+            String _generateArgumentList = this.transitionChainGenerator.generateArgumentList(gc, link);
+            _builder.append(_generateArgumentList);
+          }
+        }
+        _builder.append(") {");
+        _builder.newLineIfNotEmpty();
+        _builder.append("    ");
+        String _translatedCode = this.translator.getTranslatedCode(link.getTransition().getAction());
+        _builder.append(_translatedCode, "    ");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+        _xifexpression_2 = _builder.toString();
+      } else {
+        StringConcatenation _builder_1 = new StringConcatenation();
+        String _accessLevelProtected_1 = this.langExt.accessLevelProtected();
+        _builder_1.append(_accessLevelProtected_1);
+        String _makeOverridable = this.langExt.makeOverridable();
+        _builder_1.append(_makeOverridable);
+        _builder_1.append("void ");
+        String _actionCodeOperationName_1 = this._codegenHelpers.getActionCodeOperationName(link.getTransition());
+        _builder_1.append(_actionCodeOperationName_1);
+        _builder_1.append("(");
+        String _selfPointer_1 = this.langExt.selfPointer(this.getClassName(gc), hasArgs);
+        _builder_1.append(_selfPointer_1);
+        {
+          if (hasArgs) {
+            _builder_1.append(constIfItemPtr);
+            _builder_1.append(" ifitem");
+            String _generateArgumentList_1 = this.transitionChainGenerator.generateArgumentList(gc, link);
+            _builder_1.append(_generateArgumentList_1);
+          }
+        }
+        _builder_1.append(");");
+        _builder_1.newLineIfNotEmpty();
+        _xifexpression_2 = _builder_1.toString();
+      }
+      _xblockexpression = _xifexpression_2;
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * generate action code method implementations or declarations
+   * 
+   * @param xpax the {@link ExpandedModelComponent}
+   * @param state the {@link State}
+   * @param generateImplementation if only declarations should be generated then <code>false</code> has to be passed
+   * @return the generated code
+   */
+  @Override
+  public String genActionCodeMethods(final GraphContainer gc, final Node node, final boolean generateImplementation) {
+    String _xblockexpression = null;
+    {
+      final ModelComponent mc = this._fSMHelpers.getModelComponent(gc);
+      final String selfPtr = this.langExt.selfPointer(this.getClassName(gc), false);
+      final String opScope = this.langExt.operationScope(this.getClassName(gc), false);
+      String _xifexpression = null;
+      boolean _usesInheritance = this.langExt.usesInheritance();
+      if (_usesInheritance) {
+        _xifexpression = opScope;
+      } else {
+        _xifexpression = "";
+      }
+      final String opScopePriv = _xifexpression;
+      StateGraphNode _stateGraphNode = node.getStateGraphNode();
+      final State state = ((State) _stateGraphNode);
+      final String entryOp = this._codegenHelpers.getEntryCodeOperationName(state);
+      final String exitOp = this._codegenHelpers.getExitCodeOperationName(state);
+      final String doOp = this._codegenHelpers.getDoCodeOperationName(state);
+      String entry = this.translator.getTranslatedCode(state.getEntryCode());
+      String exit = this.translator.getTranslatedCode(state.getExitCode());
+      String docode = this.translator.getTranslatedCode(state.getDoCode());
+      if ((state instanceof RefinedState)) {
+        final String inhEntry = this.translator.getTranslatedCode(this._fSMHelpers.getInheritedEntryCode(((RefinedState)state)));
+        final String inhExit = this.translator.getTranslatedCode(this._fSMHelpers.getInheritedExitCode(((RefinedState)state)));
+        final String inhDo = this.translator.getTranslatedCode(this._fSMHelpers.getInheritedDoCode(((RefinedState)state)));
+        boolean _usesInheritance_1 = this.langExt.usesInheritance();
+        if (_usesInheritance_1) {
+          final String baseName = this.getClassName(mc.getBase());
+          boolean _hasDetailCode = this._fSMHelpers.hasDetailCode(this._fSMHelpers.getInheritedEntryCode(((RefinedState)state)));
+          if (_hasDetailCode) {
+            String _superCall = this.langExt.superCall(baseName, entryOp, "");
+            String _plus = (_superCall + entry);
+            entry = _plus;
+          }
+          boolean _hasDetailCode_1 = this._fSMHelpers.hasDetailCode(this._fSMHelpers.getInheritedExitCode(((RefinedState)state)));
+          if (_hasDetailCode_1) {
+            String _superCall_1 = this.langExt.superCall(baseName, exitOp, "");
+            String _plus_1 = (exit + _superCall_1);
+            exit = _plus_1;
+          }
+          boolean _hasDetailCode_2 = this._fSMHelpers.hasDetailCode(this._fSMHelpers.getInheritedDoCode(((RefinedState)state)));
+          if (_hasDetailCode_2) {
+            String _superCall_2 = this.langExt.superCall(baseName, doOp, "");
+            String _plus_2 = (_superCall_2 + docode);
+            docode = _plus_2;
+          }
+        } else {
+          entry = (inhEntry + entry);
+          exit = (exit + inhExit);
+          docode = (inhDo + docode);
+        }
+      }
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        boolean _isEmpty = entry.isEmpty();
+        boolean _not = (!_isEmpty);
+        if (_not) {
+          {
+            if (generateImplementation) {
+              String _accessLevelProtected = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected);
+              _builder.append("void ");
+              _builder.append(opScopePriv);
+              _builder.append(entryOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(") {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append(entry, "\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              String _accessLevelProtected_1 = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected_1);
+              String _makeOverridable = this.langExt.makeOverridable();
+              _builder.append(_makeOverridable);
+              _builder.append("void ");
+              _builder.append(entryOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      {
+        boolean _isEmpty_1 = exit.isEmpty();
+        boolean _not_1 = (!_isEmpty_1);
+        if (_not_1) {
+          {
+            if (generateImplementation) {
+              String _accessLevelProtected_2 = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected_2);
+              _builder.append("void ");
+              _builder.append(opScopePriv);
+              _builder.append(exitOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(") {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append(exit, "\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              String _accessLevelProtected_3 = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected_3);
+              String _makeOverridable_1 = this.langExt.makeOverridable();
+              _builder.append(_makeOverridable_1);
+              _builder.append("void ");
+              _builder.append(exitOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      {
+        boolean _isEmpty_2 = docode.isEmpty();
+        boolean _not_2 = (!_isEmpty_2);
+        if (_not_2) {
+          {
+            if (generateImplementation) {
+              String _accessLevelProtected_4 = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected_4);
+              _builder.append(" void ");
+              _builder.append(opScopePriv);
+              _builder.append(doOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(") {");
+              _builder.newLineIfNotEmpty();
+              _builder.append("\t");
+              _builder.append(docode, "\t");
+              _builder.newLineIfNotEmpty();
+              _builder.append("}");
+              _builder.newLine();
+            } else {
+              String _accessLevelProtected_5 = this.langExt.accessLevelProtected();
+              _builder.append(_accessLevelProtected_5);
+              String _makeOverridable_2 = this.langExt.makeOverridable();
+              _builder.append(_makeOverridable_2);
+              _builder.append("void ");
+              _builder.append(doOp);
+              _builder.append("(");
+              _builder.append(selfPtr);
+              _builder.append(");");
+              _builder.newLineIfNotEmpty();
+            }
+          }
+        }
+      }
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * let derived class add extra code after definition of constants
+   * 
+   * @param xpmc an expanded actor class
+   * @param generateImplementation or declaration only
+   * @return the generated code
+   */
+  public CharSequence genExtra(final GraphContainer gc, final boolean generateImplementation) {
+    StringConcatenation _builder = new StringConcatenation();
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/PrepareFileSystem.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/PrepareFileSystem.java
new file mode 100644
index 000000000..8d986e4ab
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/PrepareFileSystem.java
@@ -0,0 +1,131 @@
+/**
+ * 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.generator.generic;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.File;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.genmodel.etricegen.Root;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.generator.generic.RoomExtensions;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+/**
+ * A class that is used to recursively erase all folders receiving generated code
+ * an to place a readme file into those folders.
+ */
+@Singleton
+@SuppressWarnings("all")
+public class PrepareFileSystem {
+  @Inject
+  @Extension
+  private RoomExtensions _roomExtensions;
+  
+  @Inject
+  private JavaIoFileSystemAccess fileAccess;
+  
+  @Inject
+  private ILogger logger;
+  
+  public void prepareCodeTargetPaths(final Resource resource) {
+    Set<String> pathes = new HashSet<String>();
+    EList<EObject> _contents = resource.getContents();
+    for (final EObject e : _contents) {
+      if ((e instanceof Root)) {
+        EList<RoomModel> _models = ((Root) e).getModels();
+        for (final RoomModel mdl : _models) {
+          {
+            final String tgtpath = this._roomExtensions.getGenerationTargetPath(mdl);
+            if (((!Objects.equal(tgtpath, null)) && (!tgtpath.isEmpty()))) {
+              pathes.add(tgtpath);
+            }
+          }
+        }
+      }
+    }
+    this.prepare(pathes);
+  }
+  
+  public void prepareDocTargetPaths(final Resource resource) {
+    Set<String> pathes = new HashSet<String>();
+    EList<EObject> _contents = resource.getContents();
+    for (final EObject e : _contents) {
+      if ((e instanceof Root)) {
+        EList<RoomModel> _models = ((Root) e).getModels();
+        for (final RoomModel mdl : _models) {
+          {
+            final String tgtpath = this._roomExtensions.getDocGenerationTargetPath(mdl);
+            if (((!Objects.equal(tgtpath, null)) && (!tgtpath.isEmpty()))) {
+              pathes.add(tgtpath);
+            }
+          }
+        }
+      }
+    }
+    this.prepare(pathes);
+  }
+  
+  /**
+   * Recursively erase all folders receiving generated code
+   * and place a readme file in those folders.
+   * The folders are determined from the used models of every generator
+   * model found in the resource.
+   * 
+   * @param resource a {@link Resource}
+   */
+  public void prepare(final Collection<String> pathes) {
+    for (final String path : pathes) {
+      {
+        this.logger.logInfo(("clearing " + path));
+        File f = new File(path);
+        this.eraseContents(f);
+        this.fileAccess.setOutputPath(path);
+        this.fileAccess.generateFile("readme.txt", this.readmeText());
+      }
+    }
+  }
+  
+  private void eraseContents(final File f) {
+    boolean _isDirectory = f.isDirectory();
+    if (_isDirectory) {
+      File[] children = f.listFiles();
+      for (final File child : children) {
+        boolean _not = (!(child.isDirectory() && child.getName().equals("images")));
+        if (_not) {
+          this.eraseContents(child);
+          child.delete();
+        }
+      }
+    }
+  }
+  
+  private CharSequence readmeText() {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("This directory is an eTrice code generation target.");
+    _builder.newLine();
+    _builder.append("It will be erased every time the generator is executed.");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("DO NOT PLACE OTHER FILES HERE!");
+    _builder.newLine();
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java
new file mode 100644
index 000000000..e26eb6101
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java
@@ -0,0 +1,857 @@
+/**
+ * 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)
+ * 		Thomas Schuetz (refactoring, adapted for other target languages)
+ */
+package org.eclipse.etrice.generator.generic;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.fsm.fSM.DetailCode;
+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;
+import org.eclipse.etrice.core.room.ClassStructor;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.Operation;
+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.VarDecl;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.base.AbstractGenerator;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+/**
+ * A collection of methods for generation of user code, attributes with getters and setters
+ * and operations.
+ */
+@Singleton
+@SuppressWarnings("all")
+public class ProcedureHelpers {
+  protected final String NEWLINE = System.getProperty("line.separator");
+  
+  @Inject
+  @Extension
+  protected RoomHelpers _roomHelpers;
+  
+  @Inject
+  @Extension
+  protected TypeHelpers _typeHelpers;
+  
+  @Inject
+  protected ILanguageExtension languageExt;
+  
+  @Inject
+  protected ILogger logger;
+  
+  /**
+   * @param dc a {@link DataClass}
+   * @param id 0, 1 or 2 for the corresponding user codes
+   * @return the generated code
+   */
+  public CharSequence userCode(final DataClass dc, final int id) {
+    CharSequence _switchResult = null;
+    switch (id) {
+      case 1:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode1(dc));
+        break;
+      case 2:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode2(dc));
+        break;
+      case 3:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode3(dc));
+        break;
+    }
+    return _switchResult;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param id 0, 1 or 2 for the corresponding user codes
+   * @return the generated code
+   */
+  public CharSequence userCode(final ProtocolClass pc, final int id) {
+    CharSequence _switchResult = null;
+    switch (id) {
+      case 1:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode1(pc));
+        break;
+      case 2:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode2(pc));
+        break;
+      case 3:
+        _switchResult = this.userCode(this._roomHelpers.getDeepUserCode3(pc));
+        break;
+    }
+    return _switchResult;
+  }
+  
+  /**
+   * @param ac an {@link ActorContainerClass}
+   * @param id 0, 1 or 2 for the corresponding user codes
+   * @return the generated code
+   */
+  public CharSequence userCode(final ActorContainerClass ac, final int id, final boolean includeInherited) {
+    CharSequence _xifexpression = null;
+    if (includeInherited) {
+      CharSequence _switchResult = null;
+      switch (id) {
+        case 1:
+          _switchResult = this.userCode(this._roomHelpers.getDeepUserCode1(ac));
+          break;
+        case 2:
+          _switchResult = this.userCode(this._roomHelpers.getDeepUserCode2(ac));
+          break;
+        case 3:
+          _switchResult = this.userCode(this._roomHelpers.getDeepUserCode3(ac));
+          break;
+      }
+      _xifexpression = _switchResult;
+    } else {
+      CharSequence _switchResult_1 = null;
+      switch (id) {
+        case 1:
+          _switchResult_1 = this.userCode(ac.getUserCode1());
+          break;
+        case 2:
+          _switchResult_1 = this.userCode(ac.getUserCode2());
+          break;
+        case 3:
+          _switchResult_1 = this.userCode(ac.getUserCode3());
+          break;
+      }
+      _xifexpression = _switchResult_1;
+    }
+    return _xifexpression;
+  }
+  
+  /**
+   * @param dc some {@link DetailCode}
+   * @return a string containing the expanded code surrounded by
+   * 		comments (no tag replacement will happen)
+   */
+  public CharSequence userCode(final DetailCode dc) {
+    return this.userCode(this._roomHelpers.getDetailCode(dc));
+  }
+  
+  private CharSequence userCode(final String code) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      if (((!Objects.equal(code, null)) && (!code.isEmpty()))) {
+        _builder.append("/*--------------------- begin user code ---------------------*/");
+        _builder.newLine();
+        _builder.append(code);
+        _builder.newLineIfNotEmpty();
+        _builder.append("/*--------------------- end user code ---------------------*/");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param attributes a list of {@link Attribute}s
+   * @return code declaring the attributes
+   */
+  public CharSequence attributes(final List<Attribute> attributes) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/*--------------------- attributes ---------------------*/");
+    _builder.newLine();
+    {
+      for(final Attribute it : attributes) {
+        CharSequence _attributeDeclaration = this.attributeDeclaration(it);
+        _builder.append(_attributeDeclaration);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param attribute an {@link Attribute}
+   * @return the code declaring the attribute
+   */
+  public CharSequence attributeDeclaration(final Attribute attribute) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _accessLevelPublic = this.languageExt.accessLevelPublic();
+    _builder.append(_accessLevelPublic);
+    _builder.append(" ");
+    String _declarationString = this.declarationString(attribute);
+    _builder.append(_declarationString);
+    _builder.append(";");
+    _builder.newLineIfNotEmpty();
+    return _builder;
+  }
+  
+  /**
+   * @param attribute an {@link Attribute}
+   * @return the code for an array initializer
+   */
+  public String arrayInitializer(final Attribute att) {
+    String _xifexpression = null;
+    String _defaultValueLiteral = att.getDefaultValueLiteral();
+    boolean _notEquals = (!Objects.equal(_defaultValueLiteral, null));
+    if (_notEquals) {
+      _xifexpression = att.getDefaultValueLiteral();
+    } else {
+      _xifexpression = this.languageExt.defaultValue(att.getType().getType());
+    }
+    final String dflt = _xifexpression;
+    boolean _startsWith = dflt.startsWith("{");
+    if (_startsWith) {
+      int _size = ((List<String>)Conversions.doWrapArray(dflt.split(","))).size();
+      int _size_1 = att.getSize();
+      boolean _notEquals_1 = (_size != _size_1);
+      if (_notEquals_1) {
+        String _name = att.getName();
+        String _plus = ("WARNING: array size determined by initializer differs from attribute size (" + _name);
+        String _plus_1 = (_plus + "[");
+        int _size_2 = att.getSize();
+        String _plus_2 = (_plus_1 + Integer.valueOf(_size_2));
+        String _plus_3 = (_plus_2 + "] <-> ");
+        String _plus_4 = (_plus_3 + dflt);
+        String _plus_5 = (_plus_4 + ")");
+        this.logger.logInfo(_plus_5);
+      }
+      return dflt;
+    }
+    String result = "{";
+    int i = 0;
+    while ((i < att.getSize())) {
+      {
+        result = (result + dflt);
+        i = (i + 1);
+        int _size_3 = att.getSize();
+        boolean _lessThan = (i < _size_3);
+        if (_lessThan) {
+          result = (result + ", ");
+        }
+      }
+    }
+    return (result + "}");
+  }
+  
+  /**
+   * @param EnumTest a list of {@link Attribute}s
+   * @param classname the name of the defining class
+   * @return code declaring setters and getters for the attributes
+   */
+  public CharSequence attributeSettersGettersDeclaration(final List<Attribute> attributes, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/* --------------------- attribute setters and getters */");
+    _builder.newLine();
+    {
+      for(final Attribute attribute : attributes) {
+        CharSequence _setterHeader = this.setterHeader(attribute, classname);
+        _builder.append(_setterHeader);
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        CharSequence _terHeader = this.getterHeader(attribute, classname);
+        _builder.append(_terHeader);
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param EnumTest a list of {@link Attribute}s
+   * @param classname the name of the defining class
+   * @return code defining setters and getters for the attributes
+   */
+  public CharSequence attributeSettersGettersImplementation(final List<Attribute> attributes, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/* --------------------- attribute setters and getters */");
+    _builder.newLine();
+    {
+      for(final Attribute attribute : attributes) {
+        CharSequence _setterHeader = this.setterHeader(attribute, classname);
+        _builder.append(_setterHeader);
+        _builder.append(" {");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t ");
+        String _memberAccess = this.languageExt.memberAccess();
+        _builder.append(_memberAccess, "\t ");
+        String _name = attribute.getName();
+        _builder.append(_name, "\t ");
+        _builder.append(" = ");
+        String _name_1 = attribute.getName();
+        _builder.append(_name_1, "\t ");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+        CharSequence _terHeader = this.getterHeader(attribute, classname);
+        _builder.append(_terHeader);
+        _builder.append(" {");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        _builder.append("return ");
+        String _memberAccess_1 = this.languageExt.memberAccess();
+        _builder.append(_memberAccess_1, "\t");
+        String _name_2 = attribute.getName();
+        _builder.append(_name_2, "\t");
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param attribute an {@link Attribute}
+   * @param classname the name of the defining class
+   * @return code for the attribute setter declaration
+   */
+  protected CharSequence setterHeader(final Attribute attribute, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _accessLevelPublic = this.languageExt.accessLevelPublic();
+    _builder.append(_accessLevelPublic);
+    _builder.append("void set");
+    String _firstUpper = StringExtensions.toFirstUpper(attribute.getName());
+    _builder.append(_firstUpper);
+    _builder.append("(");
+    String _selfPointer = this.languageExt.selfPointer(classname, true);
+    _builder.append(_selfPointer);
+    String _argList = this.argList(Collections.<Attribute>unmodifiableList(CollectionLiterals.<Attribute>newArrayList(attribute)));
+    _builder.append(_argList);
+    _builder.append(")");
+    return _builder;
+  }
+  
+  /**
+   * @param attribute an {@link Attribute}
+   * @param classname the name of the defining class
+   * @return code for the attribute getter declaration
+   */
+  protected CharSequence getterHeader(final Attribute attribute, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _accessLevelPublic = this.languageExt.accessLevelPublic();
+    _builder.append(_accessLevelPublic);
+    String _signatureString = this.signatureString(attribute);
+    _builder.append(_signatureString);
+    _builder.append(" get");
+    String _firstUpper = StringExtensions.toFirstUpper(attribute.getName());
+    _builder.append(_firstUpper);
+    _builder.append("(");
+    String _selfPointer = this.languageExt.selfPointer(classname, false);
+    _builder.append(_selfPointer);
+    _builder.append(")");
+    return _builder;
+  }
+  
+  /**
+   * @param attributes a list of {@link Attribute}s
+   * @return an argument list for the attributes
+   */
+  public String argList(final Iterable<Attribute> attributes) {
+    final Function1<Attribute, String> _function = (Attribute it) -> {
+      String _signatureString = this.signatureString(it);
+      String _plus = (_signatureString + " ");
+      String _name = it.getName();
+      return (_plus + _name);
+    };
+    return IterableExtensions.join(IterableExtensions.<Attribute, String>map(attributes, _function), ", ");
+  }
+  
+  /**
+   * @param EnumTest an iterable of {@link Attribute}s representing a path
+   * @param classname the name of the defining class
+   * @return the invocation code for the call of a setter
+   */
+  public CharSequence invokeGetters(final Iterable<Attribute> path, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      boolean _hasElements = false;
+      for(final Attribute a : path) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(".", "");
+        }
+        CharSequence _invokeGetter = this.invokeGetter(a.getName(), classname);
+        _builder.append(_invokeGetter);
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param typeName the type name of the attribute
+   * @param name the name of the attribute
+   * @param classname the name of the type defining the getter
+   * @return code defining the attribute getter
+   */
+  public CharSequence getterImplementation(final String typeName, final String name, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _accessLevelPublic = this.languageExt.accessLevelPublic();
+    _builder.append(_accessLevelPublic);
+    _builder.append(typeName);
+    _builder.append(" get");
+    String _firstUpper = StringExtensions.toFirstUpper(name);
+    _builder.append(_firstUpper);
+    _builder.append(" (");
+    String _selfPointer = this.languageExt.selfPointer(classname, false);
+    _builder.append(_selfPointer);
+    _builder.append("){");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("return ");
+    String _memberAccess = this.languageExt.memberAccess();
+    _builder.append(_memberAccess, "\t");
+    _builder.append(name, "\t");
+    _builder.append(";");
+    _builder.newLineIfNotEmpty();
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  /**
+   * @param name the name of the attribute
+   * @param classname the name of the type defining the getter
+   * @return code defining the getter call
+   */
+  public CharSequence invokeGetter(final String name, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("get");
+    String _firstUpper = StringExtensions.toFirstUpper(name);
+    _builder.append(_firstUpper);
+    _builder.append("(");
+    String _selfPointer = this.languageExt.selfPointer(classname, true);
+    _builder.append(_selfPointer);
+    _builder.append(")");
+    return _builder;
+  }
+  
+  /**
+   * @param name the name of the attribute
+   * @param classname the name of the type defining the getter
+   * @param value the value to be assigned
+   * @return code defining the setter call
+   */
+  public CharSequence invokeSetter(final String name, final String classname, final String value) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("set");
+    String _firstUpper = StringExtensions.toFirstUpper(name);
+    _builder.append(_firstUpper);
+    _builder.append("(");
+    String _selfPointer = this.languageExt.selfPointer(classname, true);
+    _builder.append(_selfPointer);
+    _builder.append(value);
+    _builder.append(")");
+    return _builder;
+  }
+  
+  /**
+   * @param operations a list of {@link Operation}s
+   * @param classname the name of the type defining the getter
+   * @return code declaring the operations
+   */
+  public CharSequence operationsDeclaration(final List<? extends Operation> operations, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/*--------------------- operations ---------------------*/");
+    _builder.newLine();
+    {
+      for(final Operation operation : operations) {
+        CharSequence _operationSignature = this.operationSignature(operation, classname, true);
+        _builder.append(_operationSignature);
+        _builder.append(";");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder;
+  }
+  
+  /**
+   * @param operations a list of {@link Operation}s
+   * @param classname the name of the type defining the getter
+   * @return code defining the operations
+   */
+  public CharSequence operationsImplementation(final List<? extends Operation> operations, final String classname) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/*--------------------- operations ---------------------*/");
+    _builder.newLine();
+    {
+      for(final Operation operation : operations) {
+        CharSequence _operationSignature = this.operationSignature(operation, classname, false);
+        _builder.append(_operationSignature);
+        _builder.append(" {");
+        _builder.newLineIfNotEmpty();
+        _builder.append("\t");
+        String _translatedCode = AbstractGenerator.getInstance().getTranslatedCode(operation.getDetailCode());
+        _builder.append(_translatedCode, "\t");
+        _builder.newLineIfNotEmpty();
+        _builder.append("}");
+        _builder.newLine();
+      }
+    }
+    return _builder;
+  }
+  
+  public CharSequence asBlock(final CharSequence str) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("{");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append(str, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  /**
+   * invoke user structor, if (inherited) present - <b>C only</b>
+   * 
+   * @param cls {@link ActorClass} or {@link DataClass}
+   * @param args self pointer to instance
+   */
+  public String invokeUserStructor(final RoomClass cls, final String args, final boolean ctor) {
+    boolean _usesInheritance = this.languageExt.usesInheritance();
+    boolean _not = (!_usesInheritance);
+    final Function1<ClassStructor, Boolean> _function = (ClassStructor it) -> {
+      boolean _isConstructor = it.isConstructor();
+      return Boolean.valueOf((_isConstructor == ctor));
+    };
+    boolean _exists = IterableExtensions.<ClassStructor>exists(this.getStructors(cls, _not), _function);
+    if (_exists) {
+      StringConcatenation _builder = new StringConcatenation();
+      String _name = cls.getName();
+      String _xifexpression = null;
+      if (ctor) {
+        _xifexpression = "ctor";
+      } else {
+        _xifexpression = "dtor";
+      }
+      String _memberInDeclaration = this.languageExt.memberInDeclaration(_name, _xifexpression);
+      _builder.append(_memberInDeclaration);
+      _builder.append("(");
+      _builder.append(args);
+      _builder.append(");");
+      return _builder.toString();
+    }
+    return "";
+  }
+  
+  /**
+   * declaration of user constructor + destructor, if (inherited) present - <b>C only</b>
+   * 
+   * @param cls {@link ActorClass} or {@link DataClass}
+   */
+  public String userStructorsDeclaration(final RoomClass cls) {
+    String _xblockexpression = null;
+    {
+      final String namePrefix = this.languageExt.operationScope(cls.getName(), true);
+      final ArrayList<String> declBlock = CollectionLiterals.<String>newArrayList();
+      declBlock.add("/*--------------------- user constructor/destructor ---------------------*/");
+      boolean _usesInheritance = this.languageExt.usesInheritance();
+      boolean _not = (!_usesInheritance);
+      final Function1<ClassStructor, Boolean> _function = (ClassStructor it) -> {
+        return Boolean.valueOf(it.isConstructor());
+      };
+      boolean _exists = IterableExtensions.<ClassStructor>exists(this.getStructors(cls, _not), _function);
+      if (_exists) {
+        CharSequence _functionSignature = this.functionSignature(cls.getName(), (namePrefix + "ctor"), "void", "");
+        String _plus = (_functionSignature + ";");
+        declBlock.add(_plus);
+      }
+      boolean _usesInheritance_1 = this.languageExt.usesInheritance();
+      boolean _not_1 = (!_usesInheritance_1);
+      final Function1<ClassStructor, Boolean> _function_1 = (ClassStructor it) -> {
+        boolean _isConstructor = it.isConstructor();
+        return Boolean.valueOf((!_isConstructor));
+      };
+      boolean _exists_1 = IterableExtensions.<ClassStructor>exists(this.getStructors(cls, _not_1), _function_1);
+      if (_exists_1) {
+        CharSequence _functionSignature_1 = this.functionSignature(cls.getName(), (namePrefix + "dtor"), "void", "");
+        String _plus_1 = (_functionSignature_1 + ";");
+        declBlock.add(_plus_1);
+      }
+      _xblockexpression = IterableExtensions.join(declBlock, this.NEWLINE);
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * implementation of user constructor + destructor, if (inherited) present - <b>C only</b>
+   * 
+   * @param cls {@link ActorClass} or {@link DataClass}
+   */
+  public String userStructorsImplementation(final RoomClass cls) {
+    String _xblockexpression = null;
+    {
+      final ArrayList<String> declBlock = CollectionLiterals.<String>newArrayList();
+      declBlock.add("/*--------------------- user constructor/destructor ---------------------*/");
+      String _userStuctorImplementation = this.userStuctorImplementation(cls, true);
+      declBlock.add(_userStuctorImplementation);
+      String _userStuctorImplementation_1 = this.userStuctorImplementation(cls, false);
+      declBlock.add(_userStuctorImplementation_1);
+      _xblockexpression = IterableExtensions.join(IterableExtensions.<String>filterNull(declBlock), this.NEWLINE);
+    }
+    return _xblockexpression;
+  }
+  
+  protected String userStuctorImplementation(final RoomClass cls, final boolean ctor) {
+    String _xblockexpression = null;
+    {
+      final String namePrefix = this.languageExt.operationScope(cls.getName(), false);
+      boolean _usesInheritance = this.languageExt.usesInheritance();
+      boolean _not = (!_usesInheritance);
+      final Function1<ClassStructor, Boolean> _function = (ClassStructor it) -> {
+        boolean _isConstructor = it.isConstructor();
+        return Boolean.valueOf((_isConstructor == ctor));
+      };
+      boolean _exists = IterableExtensions.<ClassStructor>exists(this.getStructors(cls, _not), _function);
+      boolean _not_1 = (!_exists);
+      if (_not_1) {
+        return null;
+      }
+      StringConcatenation _builder = new StringConcatenation();
+      String _name = cls.getName();
+      String _xifexpression = null;
+      if (ctor) {
+        _xifexpression = "ctor";
+      } else {
+        _xifexpression = "dtor";
+      }
+      String _plus = (namePrefix + _xifexpression);
+      CharSequence _functionSignature = this.functionSignature(_name, _plus, "void", "");
+      _builder.append(_functionSignature);
+      _builder.append("{");
+      _builder.newLineIfNotEmpty();
+      _builder.append("\t");
+      String _userStructorBody = this.userStructorBody(cls, ctor);
+      _builder.append(_userStructorBody, "\t");
+      _builder.newLineIfNotEmpty();
+      _builder.append("}");
+      _builder.newLine();
+      _xblockexpression = _builder.toString();
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * implementation of user structor, if (inherited) present
+   */
+  public String userStructorBody(final RoomClass cls, final boolean ctor) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("/* user defined ");
+    {
+      if (ctor) {
+        _builder.append("con");
+      } else {
+        _builder.append("de");
+      }
+    }
+    _builder.append("structor body */");
+    final String comment = _builder.toString();
+    boolean _usesInheritance = this.languageExt.usesInheritance();
+    boolean _not = (!_usesInheritance);
+    final Function1<ClassStructor, Boolean> _function = (ClassStructor it) -> {
+      boolean _isConstructor = it.isConstructor();
+      return Boolean.valueOf((_isConstructor == ctor));
+    };
+    final Iterable<ClassStructor> implementedStructors = IterableExtensions.<ClassStructor>filter(this.getStructors(cls, _not), _function);
+    final Function1<ClassStructor, DetailCode> _function_1 = (ClassStructor it) -> {
+      return it.getDetailCode();
+    };
+    final Function1<DetailCode, String> _function_2 = (DetailCode it) -> {
+      return AbstractGenerator.getInstance().getTranslatedCode(it);
+    };
+    final Iterable<String> translatedCodes = IterableExtensions.<DetailCode, String>map(IterableExtensions.<ClassStructor, DetailCode>map(implementedStructors, _function_1), _function_2);
+    final Function1<String, CharSequence> _function_3 = (String it) -> {
+      CharSequence _xifexpression = null;
+      int _size = IterableExtensions.size(translatedCodes);
+      boolean _greaterThan = (_size > 1);
+      if (_greaterThan) {
+        _xifexpression = this.asBlock(it);
+      } else {
+        _xifexpression = it;
+      }
+      return _xifexpression;
+    };
+    String _join = IterableExtensions.join(IterableExtensions.<String, CharSequence>map(translatedCodes, _function_3));
+    return ((comment + this.NEWLINE) + _join);
+  }
+  
+  protected List<ClassStructor> getStructors(final RoomClass cls, final boolean inherited) {
+    List<ClassStructor> _switchResult = null;
+    final RoomClass it = cls;
+    boolean _matched = false;
+    if (it instanceof ActorClass) {
+      if ((!inherited)) {
+        _matched=true;
+        _switchResult = ((ActorClass)it).getStructors();
+      }
+    }
+    if (!_matched) {
+      if (it instanceof DataClass) {
+        if ((!inherited)) {
+          _matched=true;
+          _switchResult = ((DataClass)it).getStructors();
+        }
+      }
+    }
+    if (!_matched) {
+      if (it instanceof ActorClass) {
+        if (inherited) {
+          _matched=true;
+          _switchResult = this._roomHelpers.getAllStructors(((ActorClass)it));
+        }
+      }
+    }
+    if (!_matched) {
+      if (it instanceof DataClass) {
+        if (inherited) {
+          _matched=true;
+          _switchResult = this._roomHelpers.getAllStructors(((DataClass)it));
+        }
+      }
+    }
+    return _switchResult;
+  }
+  
+  /**
+   * @param operation an {@link Operation}
+   * @return the operation signature (with special care for
+   * 		constructor and destructor
+   */
+  protected CharSequence operationSignature(final Operation operation, final String classname, final boolean isDeclaration) {
+    CharSequence _xblockexpression = null;
+    {
+      StringConcatenation _builder = new StringConcatenation();
+      {
+        EList<VarDecl> _arguments = operation.getArguments();
+        boolean _hasElements = false;
+        for(final VarDecl argument : _arguments) {
+          if (!_hasElements) {
+            _hasElements = true;
+          } else {
+            _builder.appendImmediate(", ", "");
+          }
+          String _signatureString = this.signatureString(argument.getRefType());
+          _builder.append(_signatureString);
+          _builder.append(" ");
+          String _name = argument.getName();
+          _builder.append(_name);
+        }
+      }
+      final String arguments = _builder.toString();
+      final String returnType = this.signatureString(operation.getReturnType());
+      String _operationScope = this.languageExt.operationScope(classname, isDeclaration);
+      String _name_1 = operation.getName();
+      String _plus = (_operationScope + _name_1);
+      _xblockexpression = this.functionSignature(classname, _plus, returnType, arguments);
+    }
+    return _xblockexpression;
+  }
+  
+  /**
+   * @param type a {@link RefableType}
+   * @return a string for the type (also for pointers)
+   */
+  public String signatureString(final RefableType type) {
+    String _switchResult = null;
+    final RefableType it = type;
+    boolean _matched = false;
+    if (Objects.equal(it, null)) {
+      _matched=true;
+      _switchResult = "void";
+    }
+    if (!_matched) {
+      boolean _isRef = it.isRef();
+      if (_isRef) {
+        _matched=true;
+        String _typeName = this._typeHelpers.typeName(type.getType());
+        String _pointerLiteral = this.languageExt.pointerLiteral();
+        _switchResult = (_typeName + _pointerLiteral);
+      }
+    }
+    if (!_matched) {
+      _switchResult = this._typeHelpers.typeName(type.getType());
+    }
+    return _switchResult;
+  }
+  
+  public String signatureString(final Attribute attribute) {
+    String _switchResult = null;
+    final Attribute it = attribute;
+    boolean _matched = false;
+    int _size = it.getSize();
+    boolean _greaterThan = (_size > 0);
+    if (_greaterThan) {
+      _matched=true;
+      _switchResult = this.languageExt.arrayType(this._typeHelpers.typeName(it.getType().getType()), it.getSize(), it.getType().isRef());
+    }
+    if (!_matched) {
+      _switchResult = this.signatureString(it.getType());
+    }
+    return _switchResult;
+  }
+  
+  /**
+   * @param attribute a {@link Attribute}
+   * @return a string for <code>type name</code>
+   */
+  public String declarationString(final Attribute attribute) {
+    String _switchResult = null;
+    final Attribute it = attribute;
+    boolean _matched = false;
+    int _size = it.getSize();
+    boolean _greaterThan = (_size > 0);
+    if (_greaterThan) {
+      _matched=true;
+      _switchResult = this.languageExt.arrayDeclaration(this._typeHelpers.typeName(it.getType().getType()), it.getSize(), it.getType().isRef(), it.getName());
+    }
+    if (!_matched) {
+      String _signatureString = this.signatureString(it.getType());
+      String _plus = (_signatureString + " ");
+      String _name = it.getName();
+      _switchResult = (_plus + _name);
+    }
+    return _switchResult;
+  }
+  
+  protected CharSequence functionSignature(final String className, final String fullFctName, final String returnType, final String arguments) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _accessLevelPublic = this.languageExt.accessLevelPublic();
+    _builder.append(_accessLevelPublic);
+    _builder.append(" ");
+    _builder.append(returnType);
+    _builder.append(" ");
+    _builder.append(fullFctName);
+    _builder.append("(");
+    boolean _isEmpty = arguments.isEmpty();
+    boolean _not = (!_isEmpty);
+    String _selfPointer = this.languageExt.selfPointer(className, _not);
+    _builder.append(_selfPointer);
+    _builder.append(arguments);
+    _builder.append(")");
+    return _builder;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/RoomExtensions.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/RoomExtensions.java
new file mode 100644
index 000000000..d60d88a50
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/RoomExtensions.java
@@ -0,0 +1,611 @@
+/**
+ * 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:
+ * 		Thomas Schuetz and Henrik Rentz-Reichert (initial contribution)
+ */
+package org.eclipse.etrice.generator.generic;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import javax.inject.Inject;
+import org.eclipse.emf.common.util.BasicEList;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.genmodel.etricegen.AbstractInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.InterfaceItemInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.PortInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.SAPInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.ServiceImplInstance;
+import org.eclipse.etrice.core.genmodel.etricegen.StructureInstance;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.ExternalPort;
+import org.eclipse.etrice.core.room.GeneralProtocolClass;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageHandler;
+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.RoomClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SAP;
+import org.eclipse.etrice.core.room.SPP;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.fsm.base.FileSystemHelpers;
+import org.eclipse.etrice.generator.fsm.generic.FSMExtensions;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+/**
+ * collection of convenience functions for code generation
+ */
+@Singleton
+@SuppressWarnings("all")
+public class RoomExtensions extends FSMExtensions {
+  public final String NEWLINE = System.getProperty("line.separator");
+  
+  private static String genDir = "/src-gen/";
+  
+  private static String genInfoDir = "/src-gen-info/";
+  
+  private static String genDocDir = "/doc-gen/";
+  
+  @Inject
+  @Extension
+  protected RoomHelpers _roomHelpers;
+  
+  public static String setDefaultGenDir() {
+    return RoomExtensions.genDir = "/src-gen/";
+  }
+  
+  public static String setDefaultGenInfoDir() {
+    return RoomExtensions.genInfoDir = "/src-gen-info/";
+  }
+  
+  public static String setDefaultGenDocDir() {
+    return RoomExtensions.genDocDir = "/doc-gen/";
+  }
+  
+  public static String setGenDir(final String dir) {
+    return RoomExtensions.genDir = (("/" + dir) + "/");
+  }
+  
+  public static String setGenInfoDir(final String dir) {
+    return RoomExtensions.genInfoDir = (("/" + dir) + "/");
+  }
+  
+  public static String setGenDocDir(final String dir) {
+    return RoomExtensions.genDocDir = (("/" + dir) + "/");
+  }
+  
+  /**
+   * a specialized version of {@link #union(Iterable, Iterable)}
+   * @param in1 an iterable of type T
+   * @param in2 a second iterable of type T
+   * @return the union of the two iterables as new list
+   */
+  public List<Port> punion(final Iterable<Port> in1, final Iterable<ExternalPort> in2) {
+    final ArrayList<Port> ret = new ArrayList<Port>();
+    final Consumer<ExternalPort> _function = (ExternalPort e) -> {
+      ret.add(e.getInterfacePort());
+    };
+    in2.forEach(_function);
+    Iterables.<Port>addAll(ret, in1);
+    return ret;
+  }
+  
+  /**
+   * @return the relative path to the destination folder for the generated code
+   */
+  public String getGenerationPathSegment() {
+    return RoomExtensions.genDir;
+  }
+  
+  /**
+   * @return the relative path to the destination folder for the generated code
+   */
+  public String getGenerationInfoSegment() {
+    return RoomExtensions.genInfoDir;
+  }
+  
+  /**
+   * @return the relative path to the destination folder for the generated documentation
+   */
+  public String getDocGenerationPathSegment() {
+    return RoomExtensions.genDocDir;
+  }
+  
+  /**
+   * @param e an {@link EObject}
+   * @return the URI of the EObject's resource as file string
+   * 		(or an empty string if no such resource exists)
+   */
+  public String getModelPath(final EObject e) {
+    Resource res = e.eResource();
+    boolean _equals = Objects.equal(res, null);
+    if (_equals) {
+      return "";
+    } else {
+      return res.getURI().toFileString();
+    }
+  }
+  
+  /**
+   * @param rc a {@link RoomClass}
+   * @return the name of the room model which also serves as a package name
+   */
+  public String getPackage(final RoomClass rc) {
+    EObject _eContainer = rc.eContainer();
+    return ((RoomModel) _eContainer).getName();
+  }
+  
+  /**
+   * @param rc a {@link RoomClass}
+   * @return the name of the room model followed by the class name and all . replaced with _
+   */
+  public String getFullyQualifiedName(final RoomClass rc) {
+    String _replace = this.getPackage(rc).replace(".", "_");
+    String _plus = (_replace + "_");
+    String _name = rc.getName();
+    return (_plus + _name);
+  }
+  
+  /**
+   * @param packageName a dot (.) separated package anem
+   * @return the input with dots replaced with slashes (/)
+   */
+  public String getPathFromPackage(final String packageName) {
+    String _replaceAll = packageName.replaceAll("\\.", "/");
+    return (_replaceAll + "/");
+  }
+  
+  /**
+   * @param rc a {@link RoomClass}
+   * @return the relative folder path of the package
+   * 		(as defined by the Java convention)
+   */
+  public String getPath(final RoomClass rc) {
+    return this.getPathFromPackage(this.getPackage(rc));
+  }
+  
+  /**
+   * @param e an {@link EObject}
+   * @return the path of the Eclipse project containing the EObject's resource
+   */
+  public String getProjectPath(final EObject e) {
+    final URI res = FileSystemHelpers.getProjectURI(e);
+    boolean _equals = Objects.equal(res, null);
+    if (_equals) {
+      return "";
+    }
+    return res.toFileString();
+  }
+  
+  /**
+   * @param e an {@link EObject}
+   * @return the concatenation of the object's project path
+   * 		with the {@link #getGenerationPathSegment()}
+   */
+  public String getGenerationTargetPath(final EObject e) {
+    String _projectPath = this.getProjectPath(e);
+    String _generationPathSegment = this.getGenerationPathSegment();
+    return (_projectPath + _generationPathSegment);
+  }
+  
+  /**
+   * @param e an {@link EObject}
+   * @return the concatenation of the object's project path
+   * 		with the {@link #getGenerationInfoSegment()}
+   */
+  public String getGenerationInfoPath(final EObject e) {
+    String _projectPath = this.getProjectPath(e);
+    String _generationInfoSegment = this.getGenerationInfoSegment();
+    return (_projectPath + _generationInfoSegment);
+  }
+  
+  /**
+   * @param e an {@link EObject}
+   * @return the concatenation of the objects project path
+   * 		with the {@link #getDocGenerationPathSegment()}
+   */
+  public String getDocGenerationTargetPath(final EObject e) {
+    String _projectPath = this.getProjectPath(e);
+    String _docGenerationPathSegment = this.getDocGenerationPathSegment();
+    return (_projectPath + _docGenerationPathSegment);
+  }
+  
+  /**
+   * makes a valid identifier from a path string
+   * @param path a slash (/) separated path
+   * @return the path with slashes (and colons as in replicated actors) replaced by underscores (_)
+   */
+  public String getPathName(final String path) {
+    return path.replaceAll("/", "_").replaceAll(":", "_");
+  }
+  
+  /**
+   * @param p a {@link Port}
+   * @return a name for the associated port class
+   */
+  protected String _getPortClassName(final Port p) {
+    String _xifexpression = null;
+    GeneralProtocolClass _protocol = p.getProtocol();
+    if ((_protocol instanceof ProtocolClass)) {
+      GeneralProtocolClass _protocol_1 = p.getProtocol();
+      _xifexpression = this.getPortClassName(((ProtocolClass) _protocol_1), p.isConjugated(), p.isReplicated());
+    } else {
+      _xifexpression = "";
+    }
+    return _xifexpression;
+  }
+  
+  /**
+   * @param p a {@link ExternalPort}
+   * @return a name for the associated port class
+   */
+  protected String _getPortClassName(final ExternalPort p) {
+    return this.getPortClassName(p.getInterfacePort());
+  }
+  
+  /**
+   * @param sap a {@link SAP}
+   * @return a name for the associated port class
+   */
+  protected String _getPortClassName(final SAP sap) {
+    return this.getPortClassName(sap.getProtocol(), true);
+  }
+  
+  /**
+   * @param spp a {@link SPP}
+   * @return a name for the associated port class
+   */
+  protected String _getPortClassName(final SPP spp) {
+    return this.getPortClassName(spp.getProtocol(), false, true);
+  }
+  
+  /**
+   * @param svc a {@link ServiceImplementation}
+   * @return a name for the associated port class
+   */
+  protected String _getPortClassName(final ServiceImplementation svc) {
+    return this.getPortClassName(svc.getSpp().getProtocol(), false, true);
+  }
+  
+  /**
+   * @param p a {@link ProtocolClass}
+   * @param conj if <code>true</code> consider conjugate port, else regular
+   * @return a name for the associated port class
+   */
+  public String getPortClassName(final ProtocolClass p, final boolean conj) {
+    return this.getPortClassName(p, conj, false);
+  }
+  
+  /**
+   * @param p a {@link ProtocolClass}
+   * @param conj if <code>true</code> consider conjugate port, else regular
+   * @param repl if <code>true</code> class name for replicated port
+   * 		else for plain port
+   * @return a name for the associated port class
+   */
+  public String getPortClassName(final ProtocolClass p, final boolean conj, final boolean repl) {
+    String _name = p.getName();
+    String _xifexpression = null;
+    if (conj) {
+      _xifexpression = "Conj";
+    } else {
+      _xifexpression = "";
+    }
+    String _plus = (_name + _xifexpression);
+    String _xifexpression_1 = null;
+    if (repl) {
+      _xifexpression_1 = "Repl";
+    } else {
+      _xifexpression_1 = "";
+    }
+    String _plus_1 = (_plus + _xifexpression_1);
+    return (_plus_1 + "Port");
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired {@link PortClass}
+   * @return the port class
+   */
+  public PortClass getPortClass(final ProtocolClass pc, final boolean conj) {
+    if (conj) {
+      return pc.getConjugated();
+    } else {
+      return pc.getRegular();
+    }
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired {@link PortClass}
+   * @return the port class
+   */
+  public List<PortClass> getAllPortClasses(final ProtocolClass pc, final boolean conj) {
+    final ArrayList<PortClass> result = CollectionLiterals.<PortClass>newArrayList();
+    ProtocolClass protocol = pc;
+    while ((!Objects.equal(protocol, null))) {
+      {
+        if (conj) {
+          PortClass _conjugated = protocol.getConjugated();
+          boolean _notEquals = (!Objects.equal(_conjugated, null));
+          if (_notEquals) {
+            result.add(protocol.getConjugated());
+          }
+        } else {
+          PortClass _regular = protocol.getRegular();
+          boolean _notEquals_1 = (!Objects.equal(_regular, null));
+          if (_notEquals_1) {
+            result.add(protocol.getRegular());
+          }
+        }
+        protocol = protocol.getBase();
+      }
+    }
+    return result;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return <code>true</code> if a send handler is specified for this direction
+   */
+  public boolean handlesSend(final ProtocolClass pc, final boolean conj) {
+    PortClass _portClass = this.getPortClass(pc, conj);
+    boolean _equals = Objects.equal(_portClass, null);
+    if (_equals) {
+      return false;
+    } else {
+      final List<Message> allMessages = this._roomHelpers.getAllMessages(pc, conj);
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(this.getPortClass(pc, conj).getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMessages.contains(hdlr.getMsg());
+        if (_contains) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return <code>true</code> if a receive handler is specified for this direction
+   */
+  public boolean handlesReceive(final ProtocolClass pc, final boolean conj) {
+    PortClass _portClass = this.getPortClass(pc, conj);
+    boolean _equals = Objects.equal(_portClass, null);
+    if (_equals) {
+      return false;
+    } else {
+      final List<Message> allMessages = this._roomHelpers.getAllMessages(pc, (!conj));
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(this.getPortClass(pc, conj).getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMessages.contains(hdlr.getMsg());
+        if (_contains) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return <code>true</code> if a receive handler is specified for this direction including base classes
+   */
+  public boolean handlesReceiveIncludingSuper(final ProtocolClass pc, final boolean conj) {
+    final List<PortClass> allPortClasses = this.getAllPortClasses(pc, conj);
+    final List<Message> allMessages = this._roomHelpers.getAllMessages(pc, (!conj));
+    for (final PortClass p : allPortClasses) {
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(p.getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMessages.contains(hdlr.getMsg());
+        if (_contains) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  
+  /**
+   * @param iii an {@link InterfaceItemInstance}
+   * @return <code>true</code> if the interface item instance is logically conjugate
+   */
+  public boolean isConjugated(final InterfaceItemInstance iii) {
+    if ((iii instanceof PortInstance)) {
+      return ((PortInstance) iii).getPort().isConjugated();
+    } else {
+      if ((iii instanceof SAPInstance)) {
+        return true;
+      } else {
+        if ((iii instanceof ServiceImplInstance)) {
+          return false;
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return a list of defined receive {@link MessageHandler} for this direction
+   */
+  public List<MessageHandler> getReceiveHandlers(final ProtocolClass pc, final boolean conj) {
+    final ArrayList<MessageHandler> res = new ArrayList<MessageHandler>();
+    PortClass _portClass = this.getPortClass(pc, conj);
+    boolean _notEquals = (!Objects.equal(_portClass, null));
+    if (_notEquals) {
+      final List<Message> allMessages = this._roomHelpers.getAllMessages(pc, (!conj));
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(this.getPortClass(pc, conj).getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMessages.contains(hdlr.getMsg());
+        if (_contains) {
+          res.add(hdlr);
+        }
+      }
+    }
+    return res;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return a list of defined receive {@link MessageHandler} for this direction including base classes
+   */
+  public List<MessageHandler> getReceiveHandlersIncludingSuper(final ProtocolClass pc, final boolean conj) {
+    final ArrayList<MessageHandler> res = new ArrayList<MessageHandler>();
+    final List<PortClass> allPortClasses = this.getAllPortClasses(pc, conj);
+    final List<Message> allMsgs = this._roomHelpers.getAllMessages(pc, (!conj));
+    for (final PortClass p : allPortClasses) {
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(p.getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMsgs.contains(hdlr.getMsg());
+        if (_contains) {
+          res.add(hdlr);
+        }
+      }
+    }
+    return res;
+  }
+  
+  /**
+   * @param pc a {@link ProtocolClass}
+   * @param conj flag indicating the desired communication direction
+   * @return a list of defined send {@link MessageHandler} for this direction
+   */
+  public List<MessageHandler> getSendHandlers(final ProtocolClass pc, final boolean conj) {
+    PortClass _portClass = this.getPortClass(pc, conj);
+    boolean _equals = Objects.equal(_portClass, null);
+    if (_equals) {
+      return Collections.<MessageHandler>emptyList();
+    } else {
+      final ArrayList<MessageHandler> res = new ArrayList<MessageHandler>();
+      final List<Message> allMessages = this._roomHelpers.getAllMessages(pc, conj);
+      List<MessageHandler> _safeList = RoomExtensions.getSafeList(this.getPortClass(pc, conj).getMsgHandlers());
+      for (final MessageHandler hdlr : _safeList) {
+        boolean _contains = allMessages.contains(hdlr.getMsg());
+        if (_contains) {
+          res.add(hdlr);
+        }
+      }
+      return res;
+    }
+  }
+  
+  /**
+   * @param m a {@link Message}
+   * @param conj flag indicating the desired communication direction
+   * @return a send {@link MessageHandler} for this direction if it is defined, <code>null</code> else
+   */
+  public MessageHandler getSendHandler(final Message m, final boolean conj) {
+    EObject _eContainer = m.eContainer();
+    final Function1<MessageHandler, Boolean> _function = (MessageHandler e) -> {
+      Message _msg = e.getMsg();
+      return Boolean.valueOf(Objects.equal(_msg, m));
+    };
+    return IterableExtensions.<MessageHandler>findFirst(this.getSendHandlers(((ProtocolClass) _eContainer), conj), _function);
+  }
+  
+  /**
+   * @param m a {@link Message}
+   * @return <code>true</code> if this message is an incoming message
+   */
+  public boolean isIncoming(final Message m) {
+    EObject _eContainer = m.eContainer();
+    return this._roomHelpers.getAllIncomingMessages(((ProtocolClass) _eContainer)).contains(m);
+  }
+  
+  /**
+   * @param m a {@link Message}
+   * @return a string that can be used as identifier for the message. It is prefixed with IN_ or OUT_
+   * 		to avoid ambiguities
+   */
+  public String getCodeName(final Message m) {
+    boolean _isIncoming = this.isIncoming(m);
+    if (_isIncoming) {
+      String _name = m.getName();
+      return ("IN_" + _name);
+    } else {
+      String _name_1 = m.getName();
+      return ("OUT_" + _name_1);
+    }
+  }
+  
+  /**
+   * @param ac an {@link ActorClass}
+   * @return <code>true</code> if an operation named 'stop' is defined with a void argument list and
+   * 		void return type
+   */
+  public boolean overridesStop(final ActorClass ac) {
+    return (IterableExtensions.<StandardOperation>exists(ac.getOperations(), ((Function1<StandardOperation, Boolean>) (StandardOperation e) -> {
+      return Boolean.valueOf(((Objects.equal(e.getName(), "stop") && e.getArguments().isEmpty()) && Objects.equal(e.getReturnType(), null)));
+    })) || ((!Objects.equal(ac.getActorBase(), null)) && this.overridesStop(ac.getActorBase())));
+  }
+  
+  public BasicEList<AbstractInstance> getAllSubInstances(final StructureInstance ssi) {
+    final BasicEList<AbstractInstance> result = new BasicEList<AbstractInstance>();
+    final TreeIterator<EObject> it = ssi.eAllContents();
+    while (it.hasNext()) {
+      {
+        final EObject obj = it.next();
+        if ((obj instanceof AbstractInstance)) {
+          result.add(((AbstractInstance) obj));
+        }
+      }
+    }
+    return result;
+  }
+  
+  public static List<MessageHandler> getSafeList(final List<MessageHandler> msgHandlers) {
+    List<MessageHandler> _xifexpression = null;
+    boolean _equals = Objects.equal(msgHandlers, null);
+    if (_equals) {
+      _xifexpression = Collections.<MessageHandler>emptyList();
+    } else {
+      _xifexpression = msgHandlers;
+    }
+    return _xifexpression;
+  }
+  
+  public String getPortClassName(final EObject p) {
+    if (p instanceof Port) {
+      return _getPortClassName((Port)p);
+    } else if (p instanceof SAP) {
+      return _getPortClassName((SAP)p);
+    } else if (p instanceof SPP) {
+      return _getPortClassName((SPP)p);
+    } else if (p instanceof ExternalPort) {
+      return _getPortClassName((ExternalPort)p);
+    } else if (p instanceof ServiceImplementation) {
+      return _getPortClassName((ServiceImplementation)p);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(p).toString());
+    }
+  }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TestInstanceCreator.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TestInstanceCreator.java
new file mode 100644
index 000000000..49cf2b2d2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TestInstanceCreator.java
@@ -0,0 +1,265 @@
+package org.eclipse.etrice.generator.generic;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+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.base.Annotation;
+import org.eclipse.etrice.core.etmap.eTMap.ETMapFactory;
+import org.eclipse.etrice.core.etmap.eTMap.Mapping;
+import org.eclipse.etrice.core.etmap.eTMap.MappingModel;
+import org.eclipse.etrice.core.etmap.eTMap.SubSystemMapping;
+import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
+import org.eclipse.etrice.core.etphys.eTPhys.PhysicalModel;
+import org.eclipse.etrice.core.etphys.eTPhys.PhysicalSystem;
+import org.eclipse.etrice.core.genmodel.fsm.ILogger;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.ActorRef;
+import org.eclipse.etrice.core.room.LogicalSystem;
+import org.eclipse.etrice.core.room.RoomFactory;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.StructureClass;
+import org.eclipse.etrice.core.room.SubSystemClass;
+import org.eclipse.etrice.core.room.SubSystemRef;
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.Functions.Function2;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@FinalFieldsConstructor
+@SuppressWarnings("all")
+public class TestInstanceCreator {
+  private final static String ANNOTATION_TYPE_NAME = "TestInstance";
+  
+  @Extension
+  private final RoomFactory _roomFactory = RoomFactory.eINSTANCE;
+  
+  @Extension
+  private final ETMapFactory _eTMapFactory = ETMapFactory.eINSTANCE;
+  
+  private final ILogger logger;
+  
+  /**
+   * Creates instance and mapping for classes having <code>@TestInstance</code> annotation:
+   * <p>
+   * a) In case of a single SubSystemClass, a new LogicalSystem with a SubSystemRef will be created<br>
+   * b) For ActorClasses, one new SubSystem- and LogicalSystem with necessary refs will be created</br>
+   * Resulting ROOM classes are stored in new RoomModel within a new memory-only resource.</br>
+   * Resulting mapping is stored in a new MappingModel within a new memory-only resource.</br>
+   * </p>
+   * 
+   * Note: currently only one class having <code>@TestInstance</code> annotation is supported
+   * 
+   * @param rs ResourceSet for new resources
+   * @return false, if creation failed and generation should stop
+   */
+  public List<Resource> createInstancesAndMapping(final ResourceSet rs) {
+    final ArrayList<RoomModel> roomModels = CollectionLiterals.<RoomModel>newArrayList();
+    final ArrayList<PhysicalModel> physModels = CollectionLiterals.<PhysicalModel>newArrayList();
+    final Consumer<Resource> _function = (Resource it) -> {
+      final Function1<EObject, Boolean> _function_1 = (EObject it_1) -> {
+        boolean _switchResult = false;
+        boolean _matched = false;
+        if (it_1 instanceof RoomModel) {
+          _matched=true;
+          _switchResult = roomModels.add(((RoomModel)it_1));
+        }
+        if (!_matched) {
+          if (it_1 instanceof PhysicalModel) {
+            _matched=true;
+            _switchResult = physModels.add(((PhysicalModel)it_1));
+          }
+        }
+        return Boolean.valueOf(_switchResult);
+      };
+      IterableExtensions.<EObject>forall(it.getContents(), _function_1);
+    };
+    rs.getResources().forEach(_function);
+    final Function2<ArrayList<SubSystemClass>, RoomModel, ArrayList<SubSystemClass>> _function_1 = (ArrayList<SubSystemClass> list, RoomModel model) -> {
+      final Function1<SubSystemClass, Boolean> _function_2 = (SubSystemClass it) -> {
+        return Boolean.valueOf(this.hasTestAnnotation(it));
+      };
+      Iterable<SubSystemClass> _filter = IterableExtensions.<SubSystemClass>filter(model.getSubSystemClasses(), _function_2);
+      Iterables.<SubSystemClass>addAll(list, _filter);
+      return list;
+    };
+    final ArrayList<SubSystemClass> allTestSubSystems = IterableExtensions.<RoomModel, ArrayList<SubSystemClass>>fold(roomModels, CollectionLiterals.<SubSystemClass>newArrayList(), _function_1);
+    final List<StructureClass> allAnnotatedClasses = CollectionLiterals.<StructureClass>newArrayList(((StructureClass[])Conversions.unwrapArray(allTestSubSystems, StructureClass.class)));
+    final ArrayList<Resource> result = CollectionLiterals.<Resource>newArrayList();
+    {
+      SubSystemClass _createSubSystemClass = this._roomFactory.createSubSystemClass();
+      final Procedure1<SubSystemClass> _function_2 = (SubSystemClass it) -> {
+        it.setName("DerivedTestSubSystem");
+      };
+      final SubSystemClass derivedSubSystem = ObjectExtensions.<SubSystemClass>operator_doubleArrow(_createSubSystemClass, _function_2);
+      final Consumer<RoomModel> _function_3 = (RoomModel model) -> {
+        EList<ActorRef> _actorRefs = derivedSubSystem.getActorRefs();
+        final Function1<ActorClass, Boolean> _function_4 = (ActorClass it) -> {
+          return Boolean.valueOf(this.hasTestAnnotation(it));
+        };
+        final Function1<ActorClass, ActorRef> _function_5 = (ActorClass ac) -> {
+          ActorRef _xblockexpression = null;
+          {
+            allAnnotatedClasses.add(ac);
+            ActorRef _createActorRef = this._roomFactory.createActorRef();
+            final Procedure1<ActorRef> _function_6 = (ActorRef it) -> {
+              String _name = ac.getName();
+              String _plus = ("ref_" + _name);
+              it.setName(_plus);
+              it.setType(ac);
+            };
+            _xblockexpression = ObjectExtensions.<ActorRef>operator_doubleArrow(_createActorRef, _function_6);
+          }
+          return _xblockexpression;
+        };
+        Iterable<ActorRef> _map = IterableExtensions.<ActorClass, ActorRef>map(IterableExtensions.<ActorClass>filter(model.getActorClasses(), _function_4), _function_5);
+        Iterables.<ActorRef>addAll(_actorRefs, _map);
+      };
+      roomModels.forEach(_function_3);
+      boolean _isEmpty = derivedSubSystem.getActorRefs().isEmpty();
+      boolean _not = (!_isEmpty);
+      if (_not) {
+        allTestSubSystems.add(derivedSubSystem);
+      }
+    }
+    boolean _isEmpty = allTestSubSystems.isEmpty();
+    if (_isEmpty) {
+      return result;
+    }
+    int _size = allAnnotatedClasses.size();
+    boolean _greaterThan = (_size > 1);
+    if (_greaterThan) {
+      final Consumer<StructureClass> _function_2 = (StructureClass roomCls) -> {
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("TestInstanceCreator: mapping failed, multiple test instances present");
+        this.logger.logError(_builder.toString(), roomCls);
+      };
+      allAnnotatedClasses.forEach(_function_2);
+      return null;
+    }
+    final Function2<ArrayList<PhysicalSystem>, PhysicalModel, ArrayList<PhysicalSystem>> _function_3 = (ArrayList<PhysicalSystem> list, PhysicalModel model) -> {
+      EList<PhysicalSystem> _systems = model.getSystems();
+      Iterables.<PhysicalSystem>addAll(list, _systems);
+      return list;
+    };
+    final List<PhysicalSystem> allPhysSystems = IterableExtensions.<PhysicalModel, ArrayList<PhysicalSystem>>fold(physModels, CollectionLiterals.<PhysicalSystem>newArrayList(), _function_3);
+    int _size_1 = allPhysSystems.size();
+    boolean _notEquals = (_size_1 != 1);
+    if (_notEquals) {
+      StringConcatenation _builder = new StringConcatenation();
+      _builder.append("TestInstanceCreator: mapping failed, found ");
+      int _size_2 = allPhysSystems.size();
+      _builder.append(_size_2);
+      _builder.append(" physical systems");
+      this.logger.logError(_builder.toString(), null);
+      return null;
+    }
+    StringConcatenation _builder_1 = new StringConcatenation();
+    _builder_1.append("TestInstanceCreator: creating instance and mapping for ");
+    String _name = IterableExtensions.<StructureClass>head(allAnnotatedClasses).getName();
+    _builder_1.append(_name);
+    _builder_1.append(":");
+    String _name_1 = IterableExtensions.<StructureClass>head(allAnnotatedClasses).eClass().getName();
+    _builder_1.append(_name_1);
+    this.logger.logInfo(_builder_1.toString());
+    final PhysicalSystem physSystem = IterableExtensions.<PhysicalSystem>head(allPhysSystems);
+    final SubSystemClass testSubSystem = IterableExtensions.<SubSystemClass>head(allTestSubSystems);
+    LogicalSystem _createLogicalSystem = this._roomFactory.createLogicalSystem();
+    final Procedure1<LogicalSystem> _function_4 = (LogicalSystem it) -> {
+      it.setName("DerivedTestSystem");
+    };
+    final LogicalSystem testSystem = ObjectExtensions.<LogicalSystem>operator_doubleArrow(_createLogicalSystem, _function_4);
+    EList<SubSystemRef> _subSystems = testSystem.getSubSystems();
+    SubSystemRef _createSubSystemRef = this._roomFactory.createSubSystemRef();
+    final Procedure1<SubSystemRef> _function_5 = (SubSystemRef it) -> {
+      String _name_2 = testSubSystem.getName();
+      String _plus = ("ref_" + _name_2);
+      it.setName(_plus);
+      it.setType(testSubSystem);
+    };
+    SubSystemRef _doubleArrow = ObjectExtensions.<SubSystemRef>operator_doubleArrow(_createSubSystemRef, _function_5);
+    _subSystems.add(_doubleArrow);
+    RoomModel _createRoomModel = this._roomFactory.createRoomModel();
+    final Procedure1<RoomModel> _function_6 = (RoomModel it) -> {
+      it.setName("DerivedTestRoomModel");
+      EList<LogicalSystem> _systems = it.getSystems();
+      _systems.add(testSystem);
+      Resource _eResource = testSubSystem.eResource();
+      boolean _tripleEquals = (_eResource == null);
+      if (_tripleEquals) {
+        EList<SubSystemClass> _subSystemClasses = it.getSubSystemClasses();
+        _subSystemClasses.add(testSubSystem);
+      }
+    };
+    final RoomModel testRoomModel = ObjectExtensions.<RoomModel>operator_doubleArrow(_createRoomModel, _function_6);
+    MappingModel _createMappingModel = this._eTMapFactory.createMappingModel();
+    final Procedure1<MappingModel> _function_7 = (MappingModel it) -> {
+      it.setName("DerivedTestMappingModel");
+      EList<Mapping> _mappings = it.getMappings();
+      Mapping _createMapping = this._eTMapFactory.createMapping();
+      final Procedure1<Mapping> _function_8 = (Mapping it_1) -> {
+        it_1.setLogicalSys(testSystem);
+        it_1.setPhysicalSys(physSystem);
+        EList<SubSystemMapping> _subsysMappings = it_1.getSubsysMappings();
+        final Function1<SubSystemRef, SubSystemMapping> _function_9 = (SubSystemRef subSysRef) -> {
+          SubSystemMapping _createSubSystemMapping = this._eTMapFactory.createSubSystemMapping();
+          final Procedure1<SubSystemMapping> _function_10 = (SubSystemMapping it_2) -> {
+            it_2.setLogicalSubSys(subSysRef);
+            it_2.setNode(IterableExtensions.<NodeRef>head(physSystem.getNodeRefs()));
+          };
+          return ObjectExtensions.<SubSystemMapping>operator_doubleArrow(_createSubSystemMapping, _function_10);
+        };
+        List<SubSystemMapping> _map = ListExtensions.<SubSystemRef, SubSystemMapping>map(testSystem.getSubSystems(), _function_9);
+        Iterables.<SubSystemMapping>addAll(_subsysMappings, _map);
+      };
+      Mapping _doubleArrow_1 = ObjectExtensions.<Mapping>operator_doubleArrow(_createMapping, _function_8);
+      _mappings.add(_doubleArrow_1);
+    };
+    final MappingModel testMappingModel = ObjectExtensions.<MappingModel>operator_doubleArrow(_createMappingModel, _function_7);
+    Resource _xifexpression = null;
+    Resource _eResource = testSubSystem.eResource();
+    boolean _tripleNotEquals = (_eResource != null);
+    if (_tripleNotEquals) {
+      _xifexpression = testSubSystem.eResource();
+    } else {
+      _xifexpression = IterableExtensions.<StructureClass>head(allAnnotatedClasses).eResource();
+    }
+    final Resource existingResource = _xifexpression;
+    final URI uriPath = existingResource.getURI().trimFileExtension().trimSegments(1);
+    Resource res = rs.createResource(uriPath.appendSegment("DerivedTestMappingModel").appendFileExtension("etmap"));
+    EList<EObject> _contents = res.getContents();
+    _contents.add(testMappingModel);
+    result.add(res);
+    res = rs.createResource(uriPath.appendSegment("DerivedTestRoomModel").appendFileExtension("room"));
+    EList<EObject> _contents_1 = res.getContents();
+    _contents_1.add(testRoomModel);
+    result.add(res);
+    return result;
+  }
+  
+  protected boolean hasTestAnnotation(final StructureClass cls) {
+    final Function1<Annotation, Boolean> _function = (Annotation it) -> {
+      String _name = it.getType().getName();
+      return Boolean.valueOf(Objects.equal(_name, TestInstanceCreator.ANNOTATION_TYPE_NAME));
+    };
+    return IterableExtensions.<Annotation>exists(cls.getAnnotations(), _function);
+  }
+  
+  public TestInstanceCreator(final ILogger logger) {
+    super();
+    this.logger = logger;
+  }
+}
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 2feac2583..7c15e7750 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
@@ -5,10 +5,11 @@ Bundle-SymbolicName: org.eclipse.etrice.ui.behavior.fsm;singleton:=true
 Bundle-Version: 1.1.1.qualifier
 Bundle-Activator: org.eclipse.etrice.ui.behavior.fsm.Activator
 Bundle-Vendor: eTrice
-Require-Bundle: org.eclipse.etrice.core.common.ui;bundle-version="1.1.1",
- org.eclipse.etrice.ui.common.base;bundle-version="1.1.1",
- org.eclipse.etrice.core.fsm;bundle-version="1.1.1",
- org.eclipse.etrice.core.fsm.ui;bundle-version="1.1.1",
+Require-Bundle: org.eclipse.etrice.core.common.ui;bundle-version="1.1.0",
+ org.eclipse.etrice.ui.common.base;bundle-version="1.1.0",
+ org.eclipse.etrice.core.fsm;bundle-version="1.1.0",
+ org.eclipse.etrice.core.genmodel.fsm;bundle-version="1.1.0",
+ org.eclipse.etrice.core.fsm.ui;bundle-version="1.1.0",
  org.eclipse.graphiti;bundle-version="0.8.0",
  org.eclipse.graphiti.ui;bundle-version="0.8.0",
  org.eclipse.ui.views.properties.tabbed;bundle-version="3.5.100",
@@ -18,7 +19,8 @@ Require-Bundle: org.eclipse.etrice.core.common.ui;bundle-version="1.1.1",
  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.1"
+ org.eclipse.etrice.expressions.ui;bundle-version="1.1.1",
+ 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,
@@ -27,4 +29,5 @@ Export-Package: org.eclipse.etrice.ui.behavior.fsm.actioneditor,
  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 7ff1866c3..dc333ed18 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..153364e21 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;
@@ -28,7 +29,7 @@ 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.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;
@@ -270,4 +271,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/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..33cab8742
--- /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..5503e3f53
--- /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..e08126e73 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);
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..aca12cb84
--- /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[new Pos(
+							((text.x / graphPosAndSize.width as double) * sx + x) as int, 
+							((text.y / graphPosAndSize.height as double) * sy + y) as int
+						)]
+					}
+				}
+			}
+		]
+	}
+	
+	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 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..64243cbfd
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/src/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.xtend
@@ -0,0 +1,87 @@
+/*******************************************************************************
+ * 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
+
+/**
+ *  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() {
+		graph.links.map[it.transition].filter(Transition).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..a194ba4f4 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
@@ -23,9 +23,10 @@ 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.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;
@@ -314,12 +315,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 +332,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 +344,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 +402,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 36502564f..5de5a6031 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,12 +156,11 @@ public class StateSupport {
 			public Object[] doCreate(ICreateContext context) {
 		        
 		        ContainerShape targetContainer = context.getTargetContainer();
-		        ModelComponent ac = FSMSupportUtil.getInstance().getModelComponent(getDiagram());
+		        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, ac, targetContainer, getFeatureProvider());
+				
+				if (!FSMSupportUtil.getInstance().isOwnedBy(mc, sg)) {
+					sg = ModelEditingUtil.insertRefinedState(sg, mc, targetContainer, getFeatureProvider());
 				}
 				
 				// create new State and add it
@@ -169,7 +171,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);
 				
@@ -525,7 +527,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
@@ -588,7 +590,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);
@@ -828,7 +830,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 9f09d0234..15eb09e6b 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,9 +269,8 @@ public class TransitionSupport {
 					}
 
 					ContainerShape targetContainer = FSMSupportUtil.getInstance().getStateGraphContainer((ContainerShape) context.getSourcePictogramElement().eContainer());
-					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());
 					}
 
 					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..faadabd60
--- /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().getX());
+		
+		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..c80c570fe
--- /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.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java
new file mode 100644
index 000000000..a10e85fa2
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java
@@ -0,0 +1,114 @@
+/**
+ * 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.base.Objects;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+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.core.fsm.util.FSMHelpers;
+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.Diagram;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.mm.pictograms.PictogramLink;
+import org.eclipse.graphiti.services.Graphiti;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+/**
+ * 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
+ */
+@SuppressWarnings("all")
+public class BaseDiagramProvider {
+  private final Multimap<EObject, PictogramElement> baseDiagramBusinessObjs = ArrayListMultimap.<EObject, PictogramElement>create();
+  
+  private final FSMHelpers fsmHelpers = FSMSupportUtil.getInstance().getFSMHelpers();
+  
+  public BaseDiagramProvider(final AbstractFSMDiagramTypeProvider diagramTypeProvider) {
+    final DiagramAccessBase diagramAccess = diagramTypeProvider.getInjector().<DiagramAccessBase>getInstance(DiagramAccessBase.class);
+    EObject _businessObjectForLinkedPictogramElement = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(diagramTypeProvider.getDiagram());
+    final ModelComponent mc = ((ModelComponent) _businessObjectForLinkedPictogramElement);
+    final ResourceSet rs = diagramTypeProvider.getDiagram().eResource().getResourceSet();
+    ArrayList<ModelComponent> _newArrayList = CollectionLiterals.<ModelComponent>newArrayList();
+    final Procedure1<ArrayList<ModelComponent>> _function = (ArrayList<ModelComponent> it) -> {
+      ModelComponent base = mc.getBase();
+      while (((base != null) && it.add(base))) {
+        base = base.getBase();
+      }
+    };
+    final ArrayList<ModelComponent> baseClasses = ObjectExtensions.<ArrayList<ModelComponent>>operator_doubleArrow(_newArrayList, _function);
+    final Consumer<ModelComponent> _function_1 = (ModelComponent base) -> {
+      final Diagram baseDiagram = diagramAccess.getDiagram(base, rs);
+      boolean _notEquals = (!Objects.equal(baseDiagram, null));
+      if (_notEquals) {
+        final BiConsumer<EObject, Collection<EStructuralFeature.Setting>> _function_2 = (EObject targetEObj, Collection<EStructuralFeature.Setting> eFeatureSetting) -> {
+          final Function1<EStructuralFeature.Setting, EObject> _function_3 = (EStructuralFeature.Setting it) -> {
+            return it.getEObject();
+          };
+          final Function1<PictogramLink, PictogramElement> _function_4 = (PictogramLink it) -> {
+            return it.getPictogramElement();
+          };
+          final Consumer<PictogramElement> _function_5 = (PictogramElement pe) -> {
+            this.put(mc, targetEObj, pe);
+          };
+          IterableExtensions.<PictogramLink, PictogramElement>map(Iterables.<PictogramLink>filter(IterableExtensions.<EStructuralFeature.Setting, EObject>map(eFeatureSetting, _function_3), PictogramLink.class), _function_4).forEach(_function_5);
+        };
+        EcoreUtil.ExternalCrossReferencer.find(baseDiagram).forEach(_function_2);
+        rs.getResources().remove(baseDiagram.eResource());
+      }
+    };
+    ListExtensions.<ModelComponent>reverseView(baseClasses).forEach(_function_1);
+  }
+  
+  private boolean put(final ModelComponent mc, final EObject obj, final PictogramElement value) {
+    boolean _xblockexpression = false;
+    {
+      if ((obj instanceof StateGraph)) {
+        boolean _isTopLevel = this.fsmHelpers.isTopLevel(((StateGraph)obj));
+        if (_isTopLevel) {
+          this.baseDiagramBusinessObjs.put(mc.getStateMachine(), value);
+        }
+      }
+      _xblockexpression = this.baseDiagramBusinessObjs.put(obj, value);
+    }
+    return _xblockexpression;
+  }
+  
+  public Collection<PictogramElement> getPictograms(final EObject roomObj) {
+    Collection<PictogramElement> _xifexpression = null;
+    boolean _equals = Objects.equal(roomObj, null);
+    if (_equals) {
+      _xifexpression = CollectionLiterals.<PictogramElement>emptyList();
+    } else {
+      _xifexpression = this.baseDiagramBusinessObjs.get(roomObj);
+    }
+    return _xifexpression;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java
new file mode 100644
index 000000000..ee734afc6
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java
@@ -0,0 +1,99 @@
+/**
+ * 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 com.google.common.base.Objects;
+import com.google.inject.Injector;
+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.FSMGenElement;
+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.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class GenModelProvider {
+  private final BasicFsmGenBuilder builder;
+  
+  private final IDiagramTypeProvider fsmDiagramProvider;
+  
+  private Map<EObject, FSMGenElement> graphMap = CollectionLiterals.<EObject, FSMGenElement>newHashMap();
+  
+  private GraphContainer modelInstance = null;
+  
+  public GenModelProvider(final AbstractFSMDiagramTypeProvider fsmDiagramProvider) {
+    this.fsmDiagramProvider = fsmDiagramProvider;
+    Injector _injector = fsmDiagramProvider.getInjector();
+    BasicFsmGenBuilder _basicFsmGenBuilder = new BasicFsmGenBuilder(_injector);
+    this.builder = _basicFsmGenBuilder;
+  }
+  
+  public void updateModel() {
+    EObject _businessObjectForLinkedPictogramElement = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(this.fsmDiagramProvider.getDiagram());
+    final Procedure1<EObject> _function = (EObject it) -> {
+      GraphContainer _xifexpression = null;
+      if ((it instanceof ModelComponent)) {
+        _xifexpression = this.builder.createTransformedModel(((ModelComponent)it));
+      } else {
+        _xifexpression = null;
+      }
+      this.modelInstance = _xifexpression;
+    };
+    ObjectExtensions.<EObject>operator_doubleArrow(_businessObjectForLinkedPictogramElement, _function);
+    boolean _notEquals = (!Objects.equal(this.modelInstance, null));
+    if (_notEquals) {
+      this.graphMap.clear();
+      final Procedure1<EObject> _function_1 = (EObject it) -> {
+        boolean _matched = false;
+        if (it instanceof Graph) {
+          _matched=true;
+          this.graphMap.put(((Graph)it).getStateGraph(), ((FSMGenElement)it));
+        }
+        if (!_matched) {
+          if (it instanceof Node) {
+            _matched=true;
+            this.graphMap.put(((Node)it).getStateGraphNode(), ((FSMGenElement)it));
+          }
+        }
+        if (!_matched) {
+          if (it instanceof Link) {
+            _matched=true;
+            this.graphMap.put(((Link)it).getTransition(), ((FSMGenElement)it));
+          }
+        }
+      };
+      IteratorExtensions.<EObject>forEach(this.modelInstance.eAllContents(), _function_1);
+    }
+  }
+  
+  public GraphContainer getModel() {
+    boolean _equals = Objects.equal(this.modelInstance, null);
+    if (_equals) {
+      this.updateModel();
+    }
+    return this.modelInstance;
+  }
+  
+  public <T extends FSMGenElement> T getCasted(final EObject roomObj) {
+    FSMGenElement _get = this.graphMap.get(roomObj);
+    return ((T) _get);
+  }
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java
new file mode 100644
index 000000000..55e7293be
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java
@@ -0,0 +1,323 @@
+/**
+ * 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 com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+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.etrice.ui.behavior.fsm.support.IPositionProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.StateSupport;
+import org.eclipse.etrice.ui.behavior.fsm.support.TrPointSupport;
+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.FreeFormConnection;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.services.Graphiti;
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+/**
+ * IPositionProvider based on {@linkplain BaseDiagramProvider}
+ * 	Logic copied from DefaultPositionProvider
+ */
+@FinalFieldsConstructor
+@SuppressWarnings("all")
+public class BaseDiagramPositionProvider implements IPositionProvider {
+  private final BaseDiagramProvider baseDiagram;
+  
+  public int getMargin(final StateGraphNode node) {
+    int _switchResult = (int) 0;
+    boolean _matched = false;
+    if (node instanceof State) {
+      _matched=true;
+      _switchResult = StateSupport.MARGIN;
+    }
+    if (!_matched) {
+      if (node instanceof TrPoint) {
+        _matched=true;
+        _switchResult = TrPointSupport.MARGIN;
+      }
+    }
+    if (!_matched) {
+      _switchResult = 0;
+    }
+    return _switchResult;
+  }
+  
+  public int getMargin(final StateGraph graph) {
+    return 0;
+  }
+  
+  private IPositionProvider.PosAndSize toPosAndSize(final PictogramElement pe, final int margin) {
+    IPositionProvider.PosAndSize _xblockexpression = null;
+    {
+      EObject _eContainer = pe.eContainer();
+      final GraphicsAlgorithm borderGa = IterableExtensions.<GraphicsAlgorithm>head(((PictogramElement) _eContainer).getGraphicsAlgorithm().getGraphicsAlgorithmChildren());
+      final GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
+      int _x = ga.getX();
+      int _width = borderGa.getWidth();
+      double _divide = (_x / ((double) _width));
+      double _multiply = (_divide * this.sx);
+      final double x = (_multiply + margin);
+      int _y = ga.getY();
+      int _height = borderGa.getHeight();
+      double _divide_1 = (_y / ((double) _height));
+      double _multiply_1 = (_divide_1 * this.sy);
+      final double y = (_multiply_1 + margin);
+      int _width_1 = ga.getWidth();
+      int _minus = (_width_1 - (2 * margin));
+      int _width_2 = borderGa.getWidth();
+      double _divide_2 = (_minus / ((double) _width_2));
+      final double width = (_divide_2 * this.sx);
+      int _height_1 = ga.getHeight();
+      int _minus_1 = (_height_1 - (2 * margin));
+      int _height_2 = borderGa.getHeight();
+      double _divide_3 = (_minus_1 / ((double) _height_2));
+      final double height = (_divide_3 * this.sy);
+      _xblockexpression = new IPositionProvider.PosAndSize(((int) x), ((int) y), ((int) width), ((int) height));
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public IPositionProvider.PosAndSize getGraphPosAndSize(final StateGraph sg) {
+    IPositionProvider.PosAndSize _xblockexpression = null;
+    {
+      final Function1<PictogramElement, Boolean> _function = (PictogramElement it) -> {
+        EObject _parentBo = this.getParentBo(it);
+        return Boolean.valueOf((_parentBo instanceof ModelComponent));
+      };
+      final PictogramElement pe = IterableExtensions.<PictogramElement>findFirst(this.baseDiagram.getPictograms(sg), _function);
+      IPositionProvider.PosAndSize _xifexpression = null;
+      boolean _notEquals = (!Objects.equal(pe, null));
+      if (_notEquals) {
+        IPositionProvider.PosAndSize _xblockexpression_1 = null;
+        {
+          final GraphicsAlgorithm visibleGa = IterableExtensions.<GraphicsAlgorithm>head(pe.getGraphicsAlgorithm().getGraphicsAlgorithmChildren());
+          int _x = pe.getGraphicsAlgorithm().getX();
+          int _y = pe.getGraphicsAlgorithm().getY();
+          int _width = visibleGa.getWidth();
+          int _height = visibleGa.getHeight();
+          _xblockexpression_1 = new IPositionProvider.PosAndSize(_x, _y, _width, _height);
+        }
+        _xifexpression = _xblockexpression_1;
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public List<IPositionProvider.Pos> getPoints(final Transition trans) {
+    ArrayList<IPositionProvider.Pos> _xblockexpression = null;
+    {
+      PictogramElement _xifexpression = null;
+      if ((trans instanceof RefinedTransition)) {
+        _xifexpression = IterableExtensions.<PictogramElement>head(this.baseDiagram.getPictograms(((RefinedTransition)trans).getTarget()));
+      } else {
+        _xifexpression = IterableExtensions.<PictogramElement>head(this.baseDiagram.getPictograms(trans));
+      }
+      final PictogramElement pe = _xifexpression;
+      ArrayList<IPositionProvider.Pos> _newArrayList = CollectionLiterals.<IPositionProvider.Pos>newArrayList();
+      final Procedure1<ArrayList<IPositionProvider.Pos>> _function = (ArrayList<IPositionProvider.Pos> pointList) -> {
+        if ((pe instanceof Connection)) {
+          EObject _eContainer = trans.eContainer();
+          final IPositionProvider.PosAndSize graphPosAndSize = this.getGraphPosAndSize(((StateGraph) _eContainer));
+          final Function1<ConnectionDecorator, GraphicsAlgorithm> _function_1 = (ConnectionDecorator it) -> {
+            return it.getGraphicsAlgorithm();
+          };
+          final Text text = IterableExtensions.<Text>head(Iterables.<Text>filter(ListExtensions.<ConnectionDecorator, GraphicsAlgorithm>map(((Connection)pe).getConnectionDecorators(), _function_1), Text.class));
+          boolean _notEquals = (!Objects.equal(text, null));
+          if (_notEquals) {
+            int _x = text.getX();
+            int _width = graphPosAndSize.getWidth();
+            double _divide = (_x / ((double) _width));
+            double _multiply = (_divide * this.sx);
+            int _y = text.getY();
+            int _height = graphPosAndSize.getHeight();
+            double _divide_1 = (_y / ((double) _height));
+            double _multiply_1 = (_divide_1 * this.sy);
+            IPositionProvider.Pos _pos = new IPositionProvider.Pos(
+              ((int) _multiply), 
+              ((int) _multiply_1));
+            pointList.add(_pos);
+            if ((pe instanceof FreeFormConnection)) {
+              final Function1<Point, IPositionProvider.Pos> _function_2 = (Point it) -> {
+                int _x_1 = text.getX();
+                int _width_1 = graphPosAndSize.getWidth();
+                double _divide_2 = (_x_1 / ((double) _width_1));
+                double _multiply_2 = (_divide_2 * this.sx);
+                double _plus = (_multiply_2 + this.x);
+                int _y_1 = text.getY();
+                int _height_1 = graphPosAndSize.getHeight();
+                double _divide_3 = (_y_1 / ((double) _height_1));
+                double _multiply_3 = (_divide_3 * this.sy);
+                double _plus_1 = (_multiply_3 + this.y);
+                return new IPositionProvider.Pos(
+                  ((int) _plus), 
+                  ((int) _plus_1));
+              };
+              List<IPositionProvider.Pos> _map = ListExtensions.<Point, IPositionProvider.Pos>map(((FreeFormConnection)pe).getBendpoints(), _function_2);
+              Iterables.<IPositionProvider.Pos>addAll(pointList, _map);
+            }
+          }
+        }
+      };
+      _xblockexpression = ObjectExtensions.<ArrayList<IPositionProvider.Pos>>operator_doubleArrow(_newArrayList, _function);
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public IPositionProvider.PosAndSize getPosition(final StateGraphNode node) {
+    final Function1<EObject, IPositionProvider.PosAndSize> _function = (EObject it) -> {
+      final Function1<PictogramElement, Boolean> _function_1 = (PictogramElement it_1) -> {
+        EObject _parentBo = this.getParentBo(it_1);
+        return Boolean.valueOf((_parentBo instanceof StateGraph));
+      };
+      PictogramElement _findFirst = IterableExtensions.<PictogramElement>findFirst(this.baseDiagram.getPictograms(it), _function_1);
+      IPositionProvider.PosAndSize _posAndSize = null;
+      if (_findFirst!=null) {
+        _posAndSize=this.toPosAndSize(_findFirst, this.getMargin(node));
+      }
+      return _posAndSize;
+    };
+    final Function1<EObject, IPositionProvider.PosAndSize> getBasePos = _function;
+    IPositionProvider.PosAndSize _xifexpression = null;
+    if ((node instanceof RefinedState)) {
+      IPositionProvider.PosAndSize _elvis = null;
+      IPositionProvider.PosAndSize _apply = getBasePos.apply(node);
+      if (_apply != null) {
+        _elvis = _apply;
+      } else {
+        IPositionProvider.PosAndSize _apply_1 = getBasePos.apply(((RefinedState)node).getTarget());
+        _elvis = _apply_1;
+      }
+      _xifexpression = _elvis;
+    } else {
+      _xifexpression = getBasePos.apply(node);
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public StateGraph getInitialPoint(final StateGraph stateGraph) {
+    final PictogramElement initTransPe = IterableExtensions.<PictogramElement>head(this.baseDiagram.getPictograms(IterableExtensions.<InitialTransition>head(Iterables.<InitialTransition>filter(stateGraph.getTransitions(), InitialTransition.class))));
+    if ((initTransPe instanceof Connection)) {
+      final EObject sourceAnchorBo = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(((Connection)initTransPe).getStart());
+      if ((sourceAnchorBo instanceof StateGraph)) {
+        return ((StateGraph)sourceAnchorBo);
+      }
+    }
+    return null;
+  }
+  
+  @Override
+  public IPositionProvider.PosAndSize getPosition(final StateGraph graph) {
+    final Function1<PictogramElement, Boolean> _function = (PictogramElement it) -> {
+      EObject _parentBo = this.getParentBo(it);
+      return Boolean.valueOf((_parentBo instanceof StateGraph));
+    };
+    PictogramElement _findFirst = IterableExtensions.<PictogramElement>findFirst(this.baseDiagram.getPictograms(graph), _function);
+    IPositionProvider.PosAndSize _posAndSize = null;
+    if (_findFirst!=null) {
+      _posAndSize=this.toPosAndSize(_findFirst, this.getMargin(graph));
+    }
+    return _posAndSize;
+  }
+  
+  @Override
+  public <T extends StateGraphNode> List<IPositionProvider.PosAndSize> getPositions(final List<T> items) {
+    final Function1<T, IPositionProvider.PosAndSize> _function = (T it) -> {
+      PictogramElement _head = IterableExtensions.<PictogramElement>head(this.baseDiagram.getPictograms(it));
+      IPositionProvider.PosAndSize _posAndSize = null;
+      if (_head!=null) {
+        _posAndSize=this.toPosAndSize(_head, this.getMargin(it));
+      }
+      return _posAndSize;
+    };
+    return ListExtensions.<T, IPositionProvider.PosAndSize>map(items, _function);
+  }
+  
+  @Override
+  public double[] getSubPosition(final StateGraphNode subNode) {
+    final Function1<PictogramElement, Boolean> _function = (PictogramElement it) -> {
+      EObject _parentBo = this.getParentBo(it);
+      return Boolean.valueOf((_parentBo instanceof State));
+    };
+    final PictogramElement pe = IterableExtensions.<PictogramElement>findFirst(this.baseDiagram.getPictograms(subNode), _function);
+    boolean _notEquals = (!Objects.equal(pe, null));
+    if (_notEquals) {
+      EObject _eContainer = pe.eContainer();
+      final PictogramElement parentPe = ((PictogramElement) _eContainer);
+      int _x = pe.getGraphicsAlgorithm().getX();
+      int _width = parentPe.getGraphicsAlgorithm().getWidth();
+      int _minus = (_width - (2 * StateSupport.MARGIN));
+      final double relX = (((double) _x) / _minus);
+      int _y = pe.getGraphicsAlgorithm().getY();
+      int _height = parentPe.getGraphicsAlgorithm().getHeight();
+      int _minus_1 = (_height - (2 * StateSupport.MARGIN));
+      final double relY = (((double) _y) / _minus_1);
+      return new double[] { relX, relY };
+    }
+    return null;
+  }
+  
+  private int x;
+  
+  private int y;
+  
+  @Override
+  public void setPosition(final int x, final int y) {
+    this.x = x;
+    this.y = y;
+  }
+  
+  private double sx;
+  
+  private double sy;
+  
+  @Override
+  public void setScale(final double sx, final double sy) {
+    this.sx = sx;
+    this.sy = sy;
+  }
+  
+  private EObject getParentBo(final PictogramElement pe) {
+    EObject _eContainer = pe.eContainer();
+    return Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(((PictogramElement) _eContainer));
+  }
+  
+  public BaseDiagramPositionProvider(final BaseDiagramProvider baseDiagram) {
+    super();
+    this.baseDiagram = baseDiagram;
+  }
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java
new file mode 100644
index 000000000..9aef9f550
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java
@@ -0,0 +1,137 @@
+/**
+ * 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 com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import java.util.List;
+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.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.core.fsm.fSM.TransitionBase;
+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;
+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.ui.behavior.fsm.support.BaseDiagramPositionProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider;
+import org.eclipse.etrice.ui.behavior.fsm.support.IStateGraphContext;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+/**
+ * StateGraphContext based on newfsmgen.
+ */
+@SuppressWarnings("all")
+public class GenModelStateGraphContext implements IStateGraphContext {
+  private final GenModelProvider genModel;
+  
+  private final BaseDiagramPositionProvider baseDiagram;
+  
+  private final Graph graph;
+  
+  public GenModelStateGraphContext(final AbstractFSMDiagramTypeProvider diagramTypeProvider) {
+    this.genModel = diagramTypeProvider.getGenModelProvider();
+    BaseDiagramProvider _baseDiagramProvider = new BaseDiagramProvider(diagramTypeProvider);
+    BaseDiagramPositionProvider _baseDiagramPositionProvider = new BaseDiagramPositionProvider(_baseDiagramProvider);
+    this.baseDiagram = _baseDiagramPositionProvider;
+    this.graph = this.genModel.getModel().getGraph();
+  }
+  
+  public GenModelStateGraphContext(final Graph graph, final GenModelStateGraphContext other) {
+    this.genModel = other.genModel;
+    this.baseDiagram = other.baseDiagram;
+    this.graph = graph;
+  }
+  
+  @Override
+  public List<ChoicePoint> getChPoints() {
+    final Function1<Node, StateGraphNode> _function = (Node it) -> {
+      return it.getStateGraphNode();
+    };
+    return IterableExtensions.<ChoicePoint>toList(Iterables.<ChoicePoint>filter(ListExtensions.<Node, StateGraphNode>map(this.graph.getNodes(), _function), ChoicePoint.class));
+  }
+  
+  @Override
+  public List<IStateGraphContext> getChildren() {
+    final Function1<Node, Boolean> _function = (Node it) -> {
+      Graph _subgraph = it.getSubgraph();
+      return Boolean.valueOf((!Objects.equal(_subgraph, null)));
+    };
+    final Function1<Node, IStateGraphContext> _function_1 = (Node it) -> {
+      Graph _subgraph = it.getSubgraph();
+      GenModelStateGraphContext _genModelStateGraphContext = new GenModelStateGraphContext(_subgraph, this);
+      return ((IStateGraphContext) _genModelStateGraphContext);
+    };
+    return IterableExtensions.<IStateGraphContext>toList(IterableExtensions.<Node, IStateGraphContext>map(IterableExtensions.<Node>filter(this.graph.getNodes(), _function), _function_1));
+  }
+  
+  @Override
+  public StateGraph getInitialPoint() {
+    StateGraph _xifexpression = null;
+    final Function1<Link, TransitionBase> _function = (Link it) -> {
+      return it.getTransition();
+    };
+    boolean _isEmpty = IterableExtensions.isEmpty(Iterables.<InitialTransition>filter(ListExtensions.<Link, TransitionBase>map(this.graph.getLinks(), _function), InitialTransition.class));
+    boolean _not = (!_isEmpty);
+    if (_not) {
+      _xifexpression = this.graph.getStateGraph();
+    }
+    return _xifexpression;
+  }
+  
+  @Override
+  public State getParentState() {
+    StateGraphNode _stateGraphNode = this.graph.getNode().getStateGraphNode();
+    return ((State) _stateGraphNode);
+  }
+  
+  @Override
+  public IPositionProvider getPositionProvider() {
+    return this.baseDiagram;
+  }
+  
+  @Override
+  public StateGraph getStateGraph() {
+    return this.graph.getStateGraph();
+  }
+  
+  @Override
+  public List<State> getStates() {
+    final Function1<Node, StateGraphNode> _function = (Node it) -> {
+      return it.getStateGraphNode();
+    };
+    return IterableExtensions.<State>toList(Iterables.<State>filter(ListExtensions.<Node, StateGraphNode>map(this.graph.getNodes(), _function), State.class));
+  }
+  
+  @Override
+  public List<TrPoint> getTrPoints() {
+    final Function1<Node, StateGraphNode> _function = (Node it) -> {
+      return it.getStateGraphNode();
+    };
+    return IterableExtensions.<TrPoint>toList(Iterables.<TrPoint>filter(ListExtensions.<Node, StateGraphNode>map(this.graph.getNodes(), _function), TrPoint.class));
+  }
+  
+  @Override
+  public List<Transition> getTransitions() {
+    final Function1<Link, TransitionBase> _function = (Link it) -> {
+      return it.getTransition();
+    };
+    return IterableExtensions.<Transition>toList(Iterables.<Transition>filter(ListExtensions.<Link, TransitionBase>map(this.graph.getLinks(), _function), Transition.class));
+  }
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java
new file mode 100644
index 000000000..0a476ca09
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java
@@ -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.emf.ecore.EObject;
+import org.eclipse.graphiti.features.context.IPictogramElementContext;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.services.Graphiti;
+
+@SuppressWarnings("all")
+public class DiagramExtensions {
+  public static <T extends PictogramElement> T getCastedPe(final IPictogramElementContext ctx) {
+    PictogramElement _pictogramElement = ctx.getPictogramElement();
+    return ((T) _pictogramElement);
+  }
+  
+  public static <T extends EObject> T getCastedBo(final PictogramElement pe) {
+    EObject _businessObjectForLinkedPictogramElement = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(pe);
+    return ((T) _businessObjectForLinkedPictogramElement);
+  }
+}
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.java
new file mode 100644
index 000000000..0242ef7ac
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/ModelEditingUtil.java
@@ -0,0 +1,90 @@
+/**
+ * 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 com.google.common.base.Objects;
+import java.util.HashMap;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+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
+ */
+@SuppressWarnings("all")
+public class ModelEditingUtil {
+  public static RefinedState getOrCreateRefinedStateFor(final State s, final ModelComponent mc) {
+    final HashMap<State, RefinedState> target2rs = new HashMap<State, RefinedState>();
+    EList<State> _states = mc.getStateMachine().getStates();
+    for (final State st : _states) {
+      if ((st instanceof RefinedState)) {
+        target2rs.put(((RefinedState) st).getTarget(), ((RefinedState) st));
+      }
+    }
+    RefinedState rs = null;
+    boolean _containsKey = target2rs.containsKey(s);
+    if (_containsKey) {
+      rs = target2rs.get(s);
+    } else {
+      StateGraph sg = null;
+      State parent = s;
+      boolean break_ = false;
+      while (((parent.eContainer().eContainer() instanceof State) && (!break_))) {
+        {
+          EObject _eContainer = s.eContainer().eContainer();
+          parent = ((State) _eContainer);
+          boolean _containsKey_1 = target2rs.containsKey(parent);
+          if (_containsKey_1) {
+            final RefinedState bestFitting = target2rs.get(parent);
+            StateGraph _subgraph = bestFitting.getSubgraph();
+            boolean _equals = Objects.equal(_subgraph, null);
+            if (_equals) {
+              bestFitting.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
+            }
+            sg = bestFitting.getSubgraph();
+            break_ = true;
+          }
+        }
+      }
+      boolean _equals = Objects.equal(sg, null);
+      if (_equals) {
+        sg = mc.getStateMachine();
+      }
+      rs = FSMFactory.eINSTANCE.createRefinedState();
+      rs.setTarget(s);
+      sg.getStates().add(rs);
+    }
+    return rs;
+  }
+  
+  public static StateGraph getOrCreateSubGraphOfRefinedStateFor(final State s, final ModelComponent mc) {
+    final RefinedState rs = ModelEditingUtil.getOrCreateRefinedStateFor(s, mc);
+    StateGraph _subgraph = rs.getSubgraph();
+    boolean _equals = Objects.equal(_subgraph, null);
+    if (_equals) {
+      rs.setSubgraph(FSMFactory.eINSTANCE.createStateGraph());
+    }
+    return rs.getSubgraph();
+  }
+  
+  public static StateGraph insertRefinedState(final StateGraph sg, final ModelComponent mc, final ContainerShape targetContainer, final IFeatureProvider fp) {
+    EObject _eContainer = sg.eContainer();
+    final StateGraph sg2 = ModelEditingUtil.getOrCreateSubGraphOfRefinedStateFor(((State) _eContainer), mc);
+    fp.link(targetContainer, sg2);
+    return sg2;
+  }
+}
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/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/DiagramAccess.java
index 69ec1ea16..fdffc29c9 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,7 +21,6 @@ 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;
@@ -92,7 +91,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;
 	}
@@ -103,8 +102,7 @@ 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));
+		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/TransitionPropertyDialog.java b/plugins/org.eclipse.etrice.ui.behavior/src/org/eclipse/etrice/ui/behavior/dialogs/TransitionPropertyDialog.java
index 8099be8b6..c41969e58 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
@@ -11,6 +11,7 @@ import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.etrice.core.RoomStandaloneSetup;
 import org.eclipse.etrice.core.fsm.fSM.AbstractInterfaceItem;
 import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
 import org.eclipse.etrice.core.fsm.fSM.DetailCode;
@@ -22,10 +23,11 @@ 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.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.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.room.CommunicationType;
 import org.eclipse.etrice.core.room.InterfaceItem;
@@ -53,6 +55,8 @@ import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.ui.forms.IManagedForm;
 
+import com.google.inject.Injector;
+
 public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog implements ITransitionPropertyDialog {
 
 	protected static class NameValidator implements IValidator {
@@ -184,12 +188,9 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 			triggerError = !triggerCompartment.triggersAvailable();
 		}
 		
+		VarDecl transitionEventData = getCommonData();
+		
 		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;
@@ -269,6 +270,19 @@ public class TransitionPropertyDialog extends AbstractMemberAwarePropertyDialog
 		}
 	}
 
+	private VarDecl getCommonData() {
+		VarDecl transitionEventData = null;
+		Injector injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration();
+		ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(injector, new NullDiagnostician());
+		GraphContainer gc = builder.createTransformedModel(ac);
+		builder.withCommonData(gc);
+		Link l = FsmGenExtensions.getLinkFor(gc, trans);
+		if (l != null && l.getCommonData() instanceof VarDecl) {
+			transitionEventData = (VarDecl) l.getCommonData();
+		}
+		return transitionEventData;
+	}
+
 	/* (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 232d0ae90..99df454b1 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/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..12706b62c
--- /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..e5105bc52
--- /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..afdb3eb2e
--- /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..428ac63d5
--- /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..543d49a21
--- /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..a0311704d
--- /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..65c188bda
--- /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..4e773aa7a
--- /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..dbc900286
--- /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..e9ec6baee
--- /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..700ea77a4
--- /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..70026962a
--- /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..7514043d0
--- /dev/null
+++ b/plugins/org.eclipse.etrice.ui.runtime/contents/org.eclipse.etrice.tutorials.java.zip
diff --git a/pom.xml b/pom.xml
index 2390c681b..4b352c435 100644
--- a/pom.xml
+++ b/pom.xml
@@ -70,6 +70,7 @@
 		<module>tests/org.eclipse.etrice.core.etphys.tests</module>
 		<module>tests/org.eclipse.etrice.core.fsm.tests</module>
 		<module>tests/org.eclipse.etrice.core.genmodel.tests</module>
+		<module>tests/org.eclipse.etrice.core.genmodel.fsm.tests</module>
 		<module>tests/org.eclipse.etrice.core.room.tests</module>
 		<module>tests/org.eclipse.etrice.etunit.converter.tests</module>
 		<module>tests/org.eclipse.etrice.generator.fsmtest.tests</module>
diff --git a/runtime/org.eclipse.etrice.modellib.c/model/TimingService.room b/runtime/org.eclipse.etrice.modellib.c/model/TimingService.room
index f71a0a16f..95863bd08 100644
--- a/runtime/org.eclipse.etrice.modellib.c/model/TimingService.room
+++ b/runtime/org.eclipse.etrice.modellib.c/model/TimingService.room
@@ -149,8 +149,8 @@ RoomModel room.basic.service.timing {
 						"etTimerControlBlock* timer = getTcb();"
 						"etTime t;"
 						"if (timer!= 0){"
-						"\tt.sec=time/1000;"
-						"\tt.nSec=(time%1000)*1000000L;"
+						"\tt.sec=transitionData/1000;"
+						"\tt.nSec=(transitionData%1000)*1000000L;"
 						"\ttimer->pTime.sec = 0;"
 						"\ttimer->pTime.nSec = 0;"
 						"\ttimer->portIdx=((etReplSubPort*)ifitem)->index;"
@@ -168,8 +168,8 @@ RoomModel room.basic.service.timing {
 						"etTimerControlBlock* timer = getTcb();"
 						"etTime t;"
 						"if (timer!= 0){"
-						"\tt.sec=time/1000;"
-						"\tt.nSec=(time%1000)*1000000L;"
+						"\tt.sec=transitionData/1000;"
+						"\tt.nSec=(transitionData%1000)*1000000L;"
 						"\ttimer->pTime = t;"
 						"\ttimer->portIdx=((etReplSubPort*)ifitem)->index;"
 						"\tgetTimeFromTarget(&(timer->expTime));"
diff --git a/runtime/org.eclipse.etrice.modellib.cpp/model/TimingService.room b/runtime/org.eclipse.etrice.modellib.cpp/model/TimingService.room
index c1e56cd71..a8f0248ef 100644
--- a/runtime/org.eclipse.etrice.modellib.cpp/model/TimingService.room
+++ b/runtime/org.eclipse.etrice.modellib.cpp/model/TimingService.room
@@ -156,8 +156,8 @@ RoomModel room.basic.service.timing {
 						"etTimerControlBlock* timer = getTcb();"
 						"etTime t;"
 						"if (timer != 0) {"
-						"\tt.sec = time / 1000;"
-						"\tt.nSec = (time % 1000) * 1000000L;"
+						"\tt.sec = transitionData / 1000;"
+						"\tt.nSec = (transitionData % 1000) * 1000000L;"
 						"\ttimer->pTime.sec = 0;"
 						"\ttimer->pTime.nSec = 0;"
 						"\ttimer->portIdx = ifitem->getIdx();"
@@ -175,8 +175,8 @@ RoomModel room.basic.service.timing {
 						"etTimerControlBlock* timer = getTcb();"
 						"etTime t;"
 						"if (timer != 0) {"
-						"\tt.sec = time / 1000;"
-						"\tt.nSec = (time % 1000) * 1000000L;"
+						"\tt.sec = transitionData / 1000;"
+						"\tt.nSec = (transitionData % 1000) * 1000000L;"
 						"\ttimer->pTime = t;"
 						"\ttimer->portIdx = ifitem->getIdx();"
 						"\tgetTimeFromTarget(&(timer->expTime));"
diff --git a/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch b/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch
index f0eb39db5..a54119cbb 100644
--- a/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch
+++ b/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch
@@ -18,5 +18,4 @@
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.etrice.generator.java.Main"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc:org.eclipse.etrice.modellib.java}/model/ALogService.room&#13;&#10;${workspace_loc:org.eclipse.etrice.modellib.java}/model/TimingService.room&#13;&#10;${workspace_loc:org.eclipse.etrice.modellib.java}/model/TcpService.room&#13;&#10;-lib&#13;&#10;-msc_instr"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.java"/>
-<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
 </launchConfiguration>
diff --git a/runtime/org.eclipse.etrice.modellib.java/model/TcpService.room b/runtime/org.eclipse.etrice.modellib.java/model/TcpService.room
index 5af3819d6..152035ec0 100644
--- a/runtime/org.eclipse.etrice.modellib.java/model/TcpService.room
+++ b/runtime/org.eclipse.etrice.modellib.java/model/TcpService.room
@@ -102,7 +102,7 @@ RoomModel room.basic.service.tcp {
 					action {
 						"lastError=0;"
 						"try{"
-						"socket = new ServerSocket(data.TcpPort);"
+						"socket = new ServerSocket(transitionData.TcpPort);"
 						"(new ServerAcceptThread(PayloadPort, socket, this)).start();"
 						"}catch(IOException e){"
 						"System.err.println(e.toString());"
@@ -148,7 +148,7 @@ RoomModel room.basic.service.tcp {
 					}
 					action {
 						"try{"
-						"outStreams.get(data.getConnectionId()).write(data.getData(),0,data.length);"
+						"outStreams.get(transitionData.getConnectionId()).write(transitionData.getData(),0,transitionData.length);"
 						"}catch(IOException e){"
 						"System.err.println(e.toString());"
 						"}"
@@ -229,7 +229,7 @@ RoomModel room.basic.service.tcp {
 					action {
 						"lastError=0;"
 						"try{"
-						"socket = new Socket(data.IPAddr,data.TcpPort);"
+						"socket = new Socket(transitionData.IPAddr,transitionData.TcpPort);"
 						"(new ClientRxThread(PayloadPort, socket)).start();"
 						"out = socket.getOutputStream();"
 						"}catch(IOException e){"
@@ -276,7 +276,7 @@ RoomModel room.basic.service.tcp {
 					}
 					action {
 						"try{"
-						"\tout.write(data.getData(),0,data.length);"
+						"\tout.write(transitionData.getData(),0,transitionData.length);"
 						"\t}catch(IOException e){"
 						"\t\tSystem.err.println(e.toString());"
 						"\t}"
diff --git a/runtime/org.eclipse.etrice.modellib.java/model/TimingService.room b/runtime/org.eclipse.etrice.modellib.java/model/TimingService.room
index ed6dad1ae..588654646 100644
--- a/runtime/org.eclipse.etrice.modellib.java/model/TimingService.room
+++ b/runtime/org.eclipse.etrice.modellib.java/model/TimingService.room
@@ -37,7 +37,7 @@ RoomModel room.basic.service.timing {
 						"// start timer"
 						"taskCount++;"
 						"if (taskCount>PURGE_LIMIT) timerService.purge();"
-						"int t = td.getTime();"
+						"int t = transitionData.getTime();"
 						"timerService.scheduleAtFixedRate(((PTimerPort)ifitem).getTask(),t,t);"
 					}
 				}
@@ -49,7 +49,7 @@ RoomModel room.basic.service.timing {
 						"// start timeout"
 						"taskCount++;"
 						"if (taskCount>PURGE_LIMIT) timerService.purge();"
-						"timerService.schedule(((PTimerPort)ifitem).getTask(), ((TimerData)td).getTime());"
+						"timerService.schedule(((PTimerPort)ifitem).getTask(), transitionData.getTime());"
 					}
 				}
 				Transition tr4: Operational -> Operational {
diff --git a/runtime/org.eclipse.etrice.runtime.java/jgen_java_runtime.launch b/runtime/org.eclipse.etrice.runtime.java/jgen_java_runtime.launch
index e554de86f..037e2ffa0 100644
--- a/runtime/org.eclipse.etrice.runtime.java/jgen_java_runtime.launch
+++ b/runtime/org.eclipse.etrice.runtime.java/jgen_java_runtime.launch
@@ -10,5 +10,4 @@
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.etrice.generator.java.Main"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc:org.eclipse.etrice.runtime.java}/models/SystemServices.room&#13;&#10;-lib"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.java"/>
-<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.m2e.launchconfig.sourcepathProvider"/>
 </launchConfiguration>
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/bug417433.room b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/bug417433.room
index 6cff28eb9..34901348f 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/bug417433.room
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/bug417433.room
@@ -74,9 +74,9 @@ RoomModel org.franca.examples [ "Generated from Franca IDL model org.franca.exam
 		Attribute z: UInt16
 	}
 
-	PrimitiveType UInt16: ptInteger -> java.lang.Integer(java.lang.Integer) default "0"
-	PrimitiveType UInt32: ptInteger -> java.lang.Integer(java.lang.Integer) default "0"
-	PrimitiveType Double: ptReal -> java.lang.Double(java.lang.Double) default "0.0"
-	PrimitiveType Boolean: ptBoolean -> java.lang.Boolean(java.lang.Boolean) default "false"
+	PrimitiveType UInt16: ptInteger -> "java.lang.Integer(java.lang.Integer)" default "0"
+	PrimitiveType UInt32: ptInteger -> "java.lang.Integer(java.lang.Integer)" default "0"
+	PrimitiveType Double: ptReal -> "java.lang.Double(java.lang.Double)" default "0.0"
+	PrimitiveType Boolean: ptBoolean -> "java.lang.Boolean(java.lang.Boolean)" default "false"
 }
 
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/CashTerminal.AuthServer.behavior b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/CashTerminal.AuthServer.behavior
index d7436dce6..71480d32e 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/CashTerminal.AuthServer.behavior
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/CashTerminal.AuthServer.behavior
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="ASCII"?>
-<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of AuthServer" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link //@children.0/@children.6/@link //@children.0/@children.7/@link //@connections.5/@link //@connections.6/@link //@children.0/@children.8/@link //@connections.7/@link //@connections.8/@link //@connections.9/@link" verticalGridUnit="10" version="0.10.0">
+<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of AuthServer" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link //@children.0/@children.6/@link //@children.0/@children.7/@link //@connections.5/@link //@connections.6/@link //@children.0/@children.8/@link //@connections.7/@link //@connections.8/@link //@connections.9/@link" verticalGridUnit="10" version="0.13.0">
   <graphicsAlgorithm xsi:type="al:Rectangle" background="//@colors.1" foreground="//@colors.0" lineWidth="1" transparency="0.0" width="1000" height="1000"/>
   <link>
     <businessObjects href="../cashTerminal.room#ActorClass:AuthServer"/>
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/Semantics.AETest1.behavior b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/Semantics.AETest1.behavior
index 23384764a..44d9288c5 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/Semantics.AETest1.behavior
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/Semantics.AETest1.behavior
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="ASCII"?>
-<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of AETest1" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@children.0/@children.6/@link //@children.0/@children.7/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link //@connections.5/@link" verticalGridUnit="10" version="0.10.0">
+<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of AETest1" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@children.0/@children.6/@link //@children.0/@children.7/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link //@connections.5/@link" verticalGridUnit="10" version="0.13.0">
   <graphicsAlgorithm xsi:type="al:Rectangle" background="//@colors.1" foreground="//@colors.0" lineWidth="1" transparency="0.0" width="322" height="620"/>
   <link>
     <businessObjects href="../semantics.room#ActorClass:AETest1"/>
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/org.franca.examples.RobotArmExampleClient.behavior b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/org.franca.examples.RobotArmExampleClient.behavior
new file mode 100644
index 000000000..6ba89bbd1
--- /dev/null
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/diagrams/org.franca.examples.RobotArmExampleClient.behavior
@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="ASCII"?>
+<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of RobotArmExampleClient" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link" verticalGridUnit="10" version="0.13.0">
+  <graphicsAlgorithm xsi:type="al:Rectangle" background="//@colors.1" foreground="//@colors.0" lineWidth="1" transparency="0.0" width="1000" height="1000"/>
+  <link>
+    <businessObjects href="../bug417433.room#ActorClass:RobotArmExampleClient"/>
+  </link>
+  <children xsi:type="pi:ContainerShape" visible="true" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../bug417433.room#StateGraph:RobotArmExampleClient$sg"/>
+    </link>
+    <children visible="true">
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="40" height="40" x="100" y="100">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="10" y="10"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../bug417433.room#StateGraph:RobotArmExampleClient$sg"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.0" referencedGraphicsAlgorithm="//@children.0/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="40" height="20" y="10" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="I"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="159" height="90" x="65" y="180">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="99" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="74" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" x="49" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="49" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="49" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../bug417433.room#SimpleState:RobotArmExampleClient$waitingForMove"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.1" incomingConnections="//@connections.0" referencedGraphicsAlgorithm="//@children.0/@children.2/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="99" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="waitingForMove"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="157" height="90" x="181" y="341">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="97" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="72" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" x="48" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="48" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="48" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../bug417433.room#SimpleState:RobotArmExampleClient$waitingForGrab"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.2" incomingConnections="//@connections.1" referencedGraphicsAlgorithm="//@children.0/@children.3/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="97" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="waitingForGrab"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="176" height="90" x="386" y="180">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="116" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="91" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" x="58" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="58" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="58" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../bug417433.room#SimpleState:RobotArmExampleClient$waitingForRelease"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.3" incomingConnections="//@connections.2" referencedGraphicsAlgorithm="//@children.0/@children.4/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="116" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="waitingForRelease"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="588" y="341">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../bug417433.room#SimpleState:RobotArmExampleClient$ready"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.3" referencedGraphicsAlgorithm="//@children.0/@children.5/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="ready"/>
+      </children>
+    </children>
+  </children>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.1/@anchors.0" end="//@children.0/@children.2/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../bug417433.room#InitialTransition:RobotArmExampleClient$initial"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="init"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.2/@anchors.0" end="//@children.0/@children.3/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../bug417433.room#TriggeredTransition:RobotArmExampleClient$done1"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="done1: &lt;replyMove:me..."/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.3/@anchors.0" end="//@children.0/@children.4/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../bug417433.room#TriggeredTransition:RobotArmExampleClient$done2"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="done2: &lt;replyGrab:me..."/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.4/@anchors.0" end="//@children.0/@children.5/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../bug417433.room#TriggeredTransition:RobotArmExampleClient$done"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="done: &lt;replyRelease:..."/>
+    </connectionDecorators>
+  </connections>
+  <colors red="227" green="238" blue="249"/>
+  <colors red="255" green="255" blue="255"/>
+  <colors/>
+  <colors red="200" green="200" blue="200"/>
+  <fonts name="Arial" size="8"/>
+  <fonts name="Arial" size="9" bold="true"/>
+</pi:Diagram>
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/semantics.room b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/semantics.room
index 85c0eebd3..a1c316575 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/semantics.room
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/models/semantics.room
@@ -45,7 +45,8 @@ RoomModel Semantics {
 				}
 				Transition tr4: state1 -> wrong {
 					triggers {
-						// this trigger receives a warning
+						// this trigger receives a warning:
+						// The message violates the semantic rule
 						<in1: p0>
 					}
 				}
@@ -53,7 +54,11 @@ RoomModel Semantics {
 				State state1
 				State state2
 				State state3
+				
+				// State should handle the message in1 from port p0
 				State state4
+				
+				// State should handle the message in2 from port p0
 				State wrong
 			}
 		}
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/org.eclipse.etrice.abstractexec.behavior.tests.launch b/tests/org.eclipse.etrice.abstractexec.behavior.tests/org.eclipse.etrice.abstractexec.behavior.tests.launch
index a6708609b..16d252bd6 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/org.eclipse.etrice.abstractexec.behavior.tests.launch
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/org.eclipse.etrice.abstractexec.behavior.tests.launch
@@ -11,7 +11,7 @@
 <booleanAttribute key="clearws" value="true"/>
 <booleanAttribute key="clearwslog" value="false"/>
 <stringAttribute key="configLocation" value="${workspace_loc}/.metadata/.plugins/org.eclipse.pde.core/pde-junit"/>
-<booleanAttribute key="default" value="false"/>
+<booleanAttribute key="default" value="true"/>
 <booleanAttribute key="includeOptional" value="false"/>
 <stringAttribute key="location" value="${workspace_loc}/../junit-workspace"/>
 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
@@ -32,13 +32,13 @@
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl} -consoleLog"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.abstractexec.behavior.tests"/>
 <stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.pde.ui.workbenchClasspathProvider"/>
-<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Dosgi.requiredJavaVersion=1.8 -Xms40m -Xmx512m  -XX:MaxPermSize=256m -ea"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Dosgi.requiredJavaVersion=1.8 -Xms40m -Xmx512m  -ea"/>
 <stringAttribute key="pde.version" value="3.3"/>
 <stringAttribute key="product" value="org.eclipse.platform.ide"/>
 <booleanAttribute key="run_in_ui_thread" value="false"/>
 <stringAttribute key="selected_target_plugins" value="com.google.guava@default:default,com.google.inject@default:default,javax.inject@default:default,javax.xml@default:default,org.antlr.runtime@default:default,org.apache.commons.io@default:default,org.apache.log4j@default:default,org.eclipse.core.contenttype@default:default,org.eclipse.core.expressions@default:default,org.eclipse.core.filesystem.win32.x86_64@default:false,org.eclipse.core.filesystem@default:default,org.eclipse.core.jobs@default:default,org.eclipse.core.resources.win32.x86_64@default:false,org.eclipse.core.resources@default:default,org.eclipse.core.runtime@default:true,org.eclipse.emf.common@default:default,org.eclipse.emf.ecore.xmi@default:default,org.eclipse.emf.ecore@default:default,org.eclipse.emf@default:default,org.eclipse.equinox.app@default:default,org.eclipse.equinox.common@2:true,org.eclipse.equinox.preferences@default:default,org.eclipse.equinox.registry@default:default,org.eclipse.osgi.compatibility.state@default:false,org.eclipse.osgi@-1:true,org.eclipse.xtend.lib.macro@default:default,org.eclipse.xtend.lib@default:default,org.eclipse.xtext.common.types@default:default,org.eclipse.xtext.logging@default:false,org.eclipse.xtext.smap@default:default,org.eclipse.xtext.util@default:default,org.eclipse.xtext.xbase.lib@default:default,org.eclipse.xtext@default:default,org.hamcrest.core@default:default,org.junit@default:default,org.objectweb.asm@default:default"/>
-<stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.abstractexec.behavior.tests@default:default,org.eclipse.etrice.abstractexec.behavior@default:default,org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.genmodel.fsm@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.generator.fsm@default:default,org.eclipse.etrice.logging@default:false"/>
-<booleanAttribute key="show_selected_only" value="true"/>
+<stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.abstractexec.behavior.tests@default:default,org.eclipse.etrice.abstractexec.behavior@default:default,org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.genmodel.fsm2@default:default,org.eclipse.etrice.core.genmodel.fsm@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.generator.fsm@default:default,org.eclipse.etrice.logging@default:false"/>
+<booleanAttribute key="show_selected_only" value="false"/>
 <stringAttribute key="templateConfig" value="${target_home}\configuration\config.ini"/>
 <booleanAttribute key="tracing" value="false"/>
 <booleanAttribute key="useCustomFeatures" value="false"/>
diff --git a/tests/org.eclipse.etrice.abstractexec.behavior.tests/src/org/eclipse/etrice/abstractexec/behavior/tests/TestReachability.java b/tests/org.eclipse.etrice.abstractexec.behavior.tests/src/org/eclipse/etrice/abstractexec/behavior/tests/TestReachability.java
index a3e29c486..66654cc3d 100644
--- a/tests/org.eclipse.etrice.abstractexec.behavior.tests/src/org/eclipse/etrice/abstractexec/behavior/tests/TestReachability.java
+++ b/tests/org.eclipse.etrice.abstractexec.behavior.tests/src/org/eclipse/etrice/abstractexec/behavior/tests/TestReachability.java
@@ -22,6 +22,7 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.etrice.abstractexec.behavior.ReachabilityValidator;
 import org.eclipse.etrice.core.room.ActorClass;
 import org.eclipse.etrice.core.fsm.fSM.InitialTransition;
+import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
 import org.eclipse.etrice.core.room.RoomModel;
 import org.eclipse.etrice.core.fsm.fSM.State;
 import org.eclipse.etrice.core.fsm.fSM.StateGraph;
@@ -93,13 +94,12 @@ public class TestReachability extends TestBase {
 	}
 
 	private void checkUnreachable(StateGraphItem item) {
-		if (item instanceof InitialTransition) {
-			Assert.assertTrue(
-					item + " is incorrectly marked UNreachable (or name doesn't end with '_0' ?)",
-					item.getName().endsWith("_0"));
-		} else
-			Assert.assertTrue(
-					item + " is incorrectly marked UNreachable (or name doesn't end with '_0' ?)",
-					item.getName().endsWith("_0"));
+		String name = item.getName();
+		if (item instanceof RefinedTransition) {
+			name = ((RefinedTransition) item).getTarget().getName();
+		}
+		Assert.assertTrue(
+				name + " is incorrectly marked UNreachable (or name doesn't end with '_0' ?)",
+				name.endsWith("_0"));
 	}
 }
diff --git a/tests/org.eclipse.etrice.core.common.tests/org.eclipse.etrice.core.common.tests.launch b/tests/org.eclipse.etrice.core.common.tests/org.eclipse.etrice.core.common.tests.launch
index 171ab9d95..4c5fa5f6d 100644
--- a/tests/org.eclipse.etrice.core.common.tests/org.eclipse.etrice.core.common.tests.launch
+++ b/tests/org.eclipse.etrice.core.common.tests/org.eclipse.etrice.core.common.tests.launch
@@ -10,6 +10,7 @@
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
 <stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.common.tests"/>
 </launchConfiguration>
diff --git a/tests/org.eclipse.etrice.core.etmap.tests/org.eclipse.etrice.core.etmap.tests.launch b/tests/org.eclipse.etrice.core.etmap.tests/org.eclipse.etrice.core.etmap.tests.launch
index 99cb72aa4..5732b3f05 100644
--- a/tests/org.eclipse.etrice.core.etmap.tests/org.eclipse.etrice.core.etmap.tests.launch
+++ b/tests/org.eclipse.etrice.core.etmap.tests/org.eclipse.etrice.core.etmap.tests.launch
@@ -8,6 +8,9 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value="=org.eclipse.etrice.core.etmap.tests"/>
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
+<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.etmap.tests"/>
 </launchConfiguration>
diff --git a/tests/org.eclipse.etrice.core.etphys.tests/org.eclipse.etrice.core.etphys.tests.launch b/tests/org.eclipse.etrice.core.etphys.tests/org.eclipse.etrice.core.etphys.tests.launch
index 8a2b89ec7..ae1fb4d23 100644
--- a/tests/org.eclipse.etrice.core.etphys.tests/org.eclipse.etrice.core.etphys.tests.launch
+++ b/tests/org.eclipse.etrice.core.etphys.tests/org.eclipse.etrice.core.etphys.tests.launch
@@ -8,6 +8,9 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value="=org.eclipse.etrice.core.etphys.tests"/>
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
+<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.etphys.tests"/>
 </launchConfiguration>
diff --git a/tests/org.eclipse.etrice.core.fsm.tests/org.eclipse.etrice.core.fsm.tests.launch b/tests/org.eclipse.etrice.core.fsm.tests/org.eclipse.etrice.core.fsm.tests.launch
index 993fee367..e30656d25 100644
--- a/tests/org.eclipse.etrice.core.fsm.tests/org.eclipse.etrice.core.fsm.tests.launch
+++ b/tests/org.eclipse.etrice.core.fsm.tests/org.eclipse.etrice.core.fsm.tests.launch
@@ -8,6 +8,9 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value="=org.eclipse.etrice.core.fsm.tests"/>
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
+<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.fsm.tests"/>
 </launchConfiguration>
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.classpath b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.classpath
new file mode 100644
index 000000000..325150d24
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.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.7"/>
+	<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/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.gitignore b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.gitignore
new file mode 100644
index 000000000..d567ba01e
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.gitignore
@@ -0,0 +1,2 @@
+bin
+target
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.project b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.project
new file mode 100644
index 000000000..0121c5ab5
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.etrice.core.genmodel.fsm.tests</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/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.settings/org.eclipse.jdt.core.prefs b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 000000000..f42de363a
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/.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.7
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.7
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..2075402f5
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,15 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: FSM GenModel Tests
+Bundle-SymbolicName: org.eclipse.etrice.core.genmodel.fsm.tests
+Bundle-Version: 1.1.1.qualifier
+Bundle-Vendor: Eclipse eTrice
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Require-Bundle: org.junit;bundle-version="4.12.0",
+ org.eclipse.osgi;bundle-version="3.11.2",
+ org.eclipse.core.runtime;bundle-version="3.12.0",
+ org.eclipse.etrice.core.room;bundle-version="1.1.0",
+ org.eclipse.etrice.core.room.tests;bundle-version="1.1.0",
+ org.eclipse.etrice.core.genmodel.fsm;bundle-version="1.1.0"
+Bundle-Activator: org.eclipse.etrice.core.genmodel.fsm.tests.FSMGenModelTestsActivator
+Bundle-ActivationPolicy: lazy
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.class
deleted file mode 100644
index fafc5bbb6..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase$1.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase$1.class
deleted file mode 100644
index d9a98ca10..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase$1.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.class
deleted file mode 100644
index ea2ee56a0..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$1.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$1.class
deleted file mode 100644
index 15ed17236..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$1.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$2.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$2.class
deleted file mode 100644
index a3d1db3f0..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$2.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$3.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$3.class
deleted file mode 100644
index a911ff87c..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$3.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$4.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$4.class
deleted file mode 100644
index 2d48d9298..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$4.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$5.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$5.class
deleted file mode 100644
index b2746ac19..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$5.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$6.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$6.class
deleted file mode 100644
index 8678b3d0b..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM$6.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.class
deleted file mode 100644
index aec653fc7..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$1.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$1.class
deleted file mode 100644
index b577a8bf9..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$1.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$2.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$2.class
deleted file mode 100644
index 524155c11..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$2.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$3.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$3.class
deleted file mode 100644
index c15a16c13..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM$3.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.class
deleted file mode 100644
index 1dcb914b3..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$1.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$1.class
deleted file mode 100644
index 0565543d1..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$1.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$2.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$2.class
deleted file mode 100644
index 477da27ea..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$2.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$3.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$3.class
deleted file mode 100644
index 6140d18ac..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$3.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$4.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$4.class
deleted file mode 100644
index 5f5352f7f..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$4.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$5.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$5.class
deleted file mode 100644
index a7a8c75da..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM$5.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.class
deleted file mode 100644
index fe327bccc..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM$1.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM$1.class
deleted file mode 100644
index 7061f55ff..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM$1.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.class b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.class
deleted file mode 100644
index 6c03aaa30..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.class
+++ /dev/null
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/build.properties b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/build.properties
new file mode 100644
index 000000000..d8e2f0e92
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\
+           xtend-gen/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/models/code_inheritance.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/CodeInheritanceExample.room
index eb4226526..e117cc638 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/models/code_inheritance.room
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/CodeInheritanceExample.room
@@ -1,10 +1,6 @@
-RoomModel code_inheritance {
+RoomModel TemplateModel {
 	
-	SubSystemClass Main {
-		ActorRef appl: Deriv
-	}
-	
-	ActorClass Deriv extends Base {
+	ActorClass TestActor extends Base {
 		Structure { }
 		Behavior {
 			StateMachine {
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatFSMExample.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatFSMExample.room
new file mode 100644
index 000000000..340c2a2fc
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatFSMExample.room
@@ -0,0 +1,52 @@
+RoomModel TemplateModel {
+
+	ActorClass TestActor {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				State state0
+				State state1
+				State state2
+				State state3
+				TransitionPoint tr4
+				ChoicePoint cp0
+				Transition init0: initial -> state0
+				Transition tr0: state0 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr1: state1 -> cp cp0 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr2: cp cp0 -> state3
+				Transition tr3: cp cp0 -> state2 {
+					cond {
+						"true"
+					}
+				}
+				Transition tr5:  my tr4 -> state0 {
+					triggers {
+						<in2: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message in1()
+			Message in2()
+		}
+		outgoing { }
+	}
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatInheritedFSMExample.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatInheritedFSMExample.room
new file mode 100644
index 000000000..81fca1eaf
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/FlatInheritedFSMExample.room
@@ -0,0 +1,73 @@
+RoomModel TemplateModel {
+
+	ActorClass TestActor extends Base {
+		Behavior {
+			StateMachine {
+				State state3
+				RefinedState state1 {
+					entry {
+						"//refined"
+					}
+				}
+				Transition tr2: state1 -> state3 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				RefinedTransition tr0 {
+					action {
+						"//refined"
+					}
+				}
+				State state4
+				State state5
+				Transition tr3: state3 -> state4 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr4: state3 -> state5 {
+					triggers {
+						<in2: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ActorClass Base {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				State state0
+				State state1
+				State state2
+				Transition init0: initial -> state0
+				Transition tr0: state0 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr1: state1 -> state2 {
+					triggers {
+						<in1: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message in1()
+			Message in2()
+		}
+		outgoing { }
+	}
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierFSMExample.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierFSMExample.room
new file mode 100644
index 000000000..93b631180
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierFSMExample.room
@@ -0,0 +1,58 @@
+RoomModel TemplateModel {
+
+	ActorClass TestActor {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				State state0
+				State state1 {
+					subgraph {
+						State state1_0
+						State state1_1
+						ExitPoint tr1
+						EntryPoint tr3
+						Transition init0: initial -> state1_0
+						Transition tr0: state1_0 -> state1_1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+						Transition tr2: state1_1 -> my tr1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+						Transition tr4: my tr3 -> state1_1
+					}
+				}
+				State state2
+				Transition init0: initial -> state0
+				Transition tr0: state0 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr1: tr1 of state1 -> state2
+				Transition tr2: state2 -> tr3 of state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message in1()
+			Message in2()
+		}
+		outgoing { }
+	}
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierInheritedFSMExample.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierInheritedFSMExample.room
new file mode 100644
index 000000000..8c4da3559
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/HierInheritedFSMExample.room
@@ -0,0 +1,122 @@
+RoomModel TemplateModel {
+
+
+	abstract ActorClass Base {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				State state0
+				State state2
+				State state1 {
+					subgraph {
+						EntryPoint tr0
+						ExitPoint tr1
+						Transition init0: initial -> state1_0
+						State state1_0
+						State state1_1
+						Transition tr2: state1_0 -> state1_1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+					}
+				}
+				Transition init0: initial -> state0
+				Transition tr0: state0 -> tr0 of state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition tr1: tr1 of state1 -> state2
+				Transition tr2: state2 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ActorClass TestActor extends Base {
+		Behavior {
+			StateMachine {
+				RefinedState state1 {
+					subgraph {
+						State state1_2
+						Transition tr4: my tr0 -> state1_2
+						Transition tr5: state1_2 -> my tr1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+						Transition tr6: state1_2 -> state1_0 {
+							triggers {
+								<in2: p0>
+							}
+						}
+						RefinedState state1_1 {
+							subgraph {
+								State state1_1_0
+								State state1_1_1
+								Transition tr1: initial -> state1_1_0
+								Transition tr2: state1_1_0 -> state1_1_1 {
+									triggers {
+										<in1: p0>
+									}
+								}
+							}
+						}
+					}
+				}
+				RefinedState state0 {
+					subgraph {
+						State state0_0
+						Transition tr1: initial -> state0_0
+					}
+				}
+				State state3
+				Transition tr3: state0 -> state3 {
+					triggers {
+						<in2: p0>
+					}
+				}
+				Transition tr4: state3 -> tr0 of state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass TestActor2 extends TestActor {
+		Behavior {
+			StateMachine {
+				RefinedState state0 {
+					entry {
+						""
+					}
+				}
+				RefinedTransition tr3 {
+					action {
+						""
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message in1()
+			Message in2()
+		}
+		outgoing { }
+	}
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/models/cpmult.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/MultipleConnectedChoicepointExample.room
index ffbc47c24..ddaeabc48 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/models/cpmult.room
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/MultipleConnectedChoicepointExample.room
@@ -1,11 +1,8 @@
-RoomModel cpmult {
-	import room.basic.types.* from "../../org.eclipse.etrice.modellib.java/models/Types.room"
+RoomModel TemplateModel {
 
-	SubSystemClass Main {
-		ActorRef appl: CPMult
-	}
+	import room.basic.types.* from "Types.room"
 	
-	ActorClass CPMult {
+	ActorClass TestActor {
 		Interface {
 			Port p0: PC
 		}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/models/states_inheritance.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/StatesInheritanceExample.room
index 5d9a4d00b..354489aa8 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/models/states_inheritance.room
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/StatesInheritanceExample.room
@@ -64,22 +64,7 @@ RoomModel states_inheritance.t {
 		}
 	}
 
-	SubSystemClass CMain {
-		ActorRef application : AApplication_CMain
-		ActorRef timingService : ATimingService
-
-		LayerConnection ref application satisfied_by timingService.timerSPP
-		LayerConnection ref application satisfied_by timingService.timeoutSPP
-	}
-
-	// automatically inserted AApplication_CMain
-	ActorClass AApplication_CMain {
-		Structure {
-			ActorRef test : ADerived
-		}
-	}
-
-	ActorClass ATest {
+	ActorClass ABase {
 		Interface {
 			Port fct : PTest1
 		}
@@ -182,7 +167,7 @@ RoomModel states_inheritance.t {
 		}
 	}
 
-	ActorClass ADerived extends ATest {
+	ActorClass TestActor extends ABase {
 		Interface {
 			Port port : PTest3
 		}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/models/states_triggers.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/StatesTriggersExample.room
index 9d61c910c..46ee6dede 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/models/states_triggers.room
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/StatesTriggersExample.room
@@ -1,6 +1,6 @@
-RoomModel states_trigers {
+RoomModel TemplateModel {
 
-	PrimitiveType int32: ptInteger -> int32 (Integer) default "0"
+	PrimitiveType int32: ptInteger -> "int32" (Integer) default "0"
 
 	ProtocolClass PTimer {
 		incoming {
@@ -55,22 +55,7 @@ RoomModel states_trigers {
 		}
 	}
 
-	SubSystemClass CMain {
-		ActorRef application : AApplication_CMain
-		ActorRef timingService : ATimingService
-
-		LayerConnection ref application satisfied_by timingService.timerSPP
-		LayerConnection ref application satisfied_by timingService.timeoutSPP
-	}
-
-	// automatically inserted AApplication_CMain
-	ActorClass AApplication_CMain {
-		Structure {
-			ActorRef test : ATest
-		}
-	}
-
-	ActorClass ATest {
+	ActorClass TestActor {
 		Interface {
 			Port fct : PTest1
 		}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/TriggerExample.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/TriggerExample.room
new file mode 100644
index 000000000..bd6c646b6
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/TriggerExample.room
@@ -0,0 +1,87 @@
+RoomModel TemplateModel {
+
+	ActorClass TestActor {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				State state0 {
+					subgraph {
+						State state0_0
+						State state0_1
+						Transition init0: initial -> state0_0
+						Transition in3: state0_0 -> state0_1 {
+							triggers {
+								<in3: p0>
+							}
+						}
+						Transition in2: state0_1 -> state0_0 {
+							triggers {
+								<in2: p0>
+							}
+						}
+					}
+				}
+				State state1 {
+					subgraph {
+						State state1_0
+						State state1_1
+						Transition init0: initial -> state1_0
+						Transition in1: state1_0 -> state1_1 {
+							triggers {
+								<in1: p0>
+							}
+						}
+						Transition in1wGuard: state1_1 -> state1_0 {
+							triggers {
+								<in1: p0 guard {
+									"condA"
+								}>
+							}
+						}
+					}
+				}
+				State state2
+				TransitionPoint tr2
+				Transition init0: initial -> state0
+				Transition in1: state0 -> state1 {
+					triggers {
+						<in1: p0>
+					}
+				}
+				Transition in1withGuard: state1 -> state2 {
+					triggers {
+						<in1: p0 guard {
+							"condA"
+						}>
+					}
+				}
+				Transition in2: my tr2 -> my tr2 {
+					triggers {
+						<in2: p0>
+					}
+				}
+				Transition in1WoGuard: state1 -> state2 {
+					triggers {
+						<in1: p0>
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message in1()
+			Message in2()
+			Message in3()
+			Message in4()
+		}
+		outgoing { }
+	}
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/Types.room b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/Types.room
new file mode 100644
index 000000000..b27d100f4
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/models/Types.room
@@ -0,0 +1,13 @@
+RoomModel room.basic.types {
+
+	PrimitiveType boolean: ptBoolean -> 'boolean' (Boolean) default 'false'
+	PrimitiveType char: ptCharacter -> 'char' (Char) default ''
+	PrimitiveType int8: ptInteger -> 'byte' (Byte) default '0'
+	PrimitiveType int16: ptInteger -> 'short' (Short) default '0'
+	PrimitiveType int32: ptInteger -> 'int' (Integer) default '0'
+	PrimitiveType int64: ptInteger -> 'long' (Long) default '0'
+	PrimitiveType float32: ptReal -> 'float' (Float) default '0'
+	PrimitiveType float64: ptReal -> 'double' (Double) default '0'
+	PrimitiveType string: ptCharacter -> 'String' (String) default ''
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/org.eclipse.etrice.core.genmodel.fsm.tests.launch b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/org.eclipse.etrice.core.genmodel.fsm.tests.launch
new file mode 100644
index 000000000..3c8ac48e9
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/org.eclipse.etrice.core.genmodel.fsm.tests.launch
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.pde.ui.JunitLaunchConfig">
+<booleanAttribute key="append.args" value="true"/>
+<stringAttribute key="application" value="org.eclipse.pde.junit.runtime.coretestapplication"/>
+<booleanAttribute key="askclear" value="false"/>
+<booleanAttribute key="automaticAdd" value="true"/>
+<booleanAttribute key="automaticValidate" value="true"/>
+<stringAttribute key="bootstrap" value=""/>
+<stringAttribute key="checked" value="[NONE]"/>
+<booleanAttribute key="clearConfig" value="true"/>
+<booleanAttribute key="clearws" value="true"/>
+<booleanAttribute key="clearwslog" value="false"/>
+<stringAttribute key="configLocation" value="${workspace_loc}/.metadata/.plugins/org.eclipse.pde.core/pde-junit"/>
+<booleanAttribute key="default" value="true"/>
+<booleanAttribute key="includeOptional" value="true"/>
+<stringAttribute key="location" value="${workspace_loc}/../junit-workspace"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.etrice.core.genmodel.fsm.tests"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value="=org.eclipse.etrice.core.genmodel.fsm.tests"/>
+<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
+<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
+<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<booleanAttribute key="org.eclipse.jdt.launching.ATTR_USE_START_ON_FIRST_THREAD" value="true"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl} -consoleLog"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.core.genmodel.fsm.tests"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.pde.ui.workbenchClasspathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Dosgi.requiredJavaVersion=1.8 -Xms40m -Xmx512m  -ea"/>
+<stringAttribute key="pde.version" value="3.3"/>
+<stringAttribute key="product" value="org.eclipse.epp.package.dsl.product"/>
+<booleanAttribute key="run_in_ui_thread" value="false"/>
+<booleanAttribute key="show_selected_only" value="false"/>
+<stringAttribute key="templateConfig" value="${target_home}\configuration\config.ini"/>
+<booleanAttribute key="tracing" value="false"/>
+<booleanAttribute key="useCustomFeatures" value="false"/>
+<booleanAttribute key="useDefaultConfig" value="true"/>
+<booleanAttribute key="useDefaultConfigArea" value="false"/>
+<booleanAttribute key="useProduct" value="false"/>
+</launchConfiguration>
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/output/.gitignore b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/output/.gitignore
new file mode 100644
index 000000000..ccd488a3d
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/output/.gitignore
@@ -0,0 +1 @@
+*.fsmgen
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.java
new file mode 100644
index 000000000..c947ef93f
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/FSMGenModelTestsActivator.java
@@ -0,0 +1,37 @@
+package org.eclipse.etrice.core.genmodel.fsm.tests;
+
+import org.eclipse.core.runtime.Plugin;
+import org.eclipse.emf.ecore.util.Diagnostician;
+import org.eclipse.etrice.core.RoomStandaloneSetup;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+
+public class FSMGenModelTestsActivator extends Plugin implements BundleActivator {
+
+	private static FSMGenModelTestsActivator instance = null;
+	
+	@Inject
+	private Diagnostician diagnostician;
+	
+	public static FSMGenModelTestsActivator getInstance() {
+		return instance;
+	}
+	
+	@Override
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		
+		instance = this;
+        
+		Injector injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration();
+        injector.injectMembers(this);
+	}
+
+	public Diagnostician getDiagnostician() {
+		return diagnostician;
+	}
+
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.xtend
index 57de115da..e6cf80196 100644
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.xtend
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.xtend
@@ -12,33 +12,37 @@
 
 package org.eclipse.etrice.core.genmodel.fsm.tests
 
+import org.eclipse.emf.common.util.URI
 import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
 import org.eclipse.etrice.core.RoomStandaloneSetup
 import org.eclipse.etrice.core.TestBase
-import org.eclipse.etrice.core.genmodel.fsm.FsmGenBuilder
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician
+import org.eclipse.etrice.core.genmodel.fsm.NullDiagnostician
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
 import org.eclipse.etrice.core.room.ActorClass
 import org.eclipse.etrice.core.room.RoomModel
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
-import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
-import org.eclipse.emf.common.util.URI
 
 class FsmGenTestBase extends TestBase {
 
 	protected Resource res = null
 	protected ActorClass actor
+	protected IDiagnostician diagnostician = new NullDiagnostician
+	protected extension ExtendedFsmGenBuilder builder
 
 	protected def getGraphContainer(String roomFile, String actorName) {
 		prepare(FSMGenModelTestsActivator.getInstance().getBundle())
 		res = getResource(roomFile)
 		actor = (res.contents.get(0) as RoomModel).actorClasses.findFirst[name.equals(actorName)]
 		val injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration()
-		val FsmGenBuilder builder = new FsmGenBuilder(injector)
+		builder = new ExtendedFsmGenBuilder(injector, diagnostician)
 		builder.createTransformedModel(actor)
 	}
 	
 	protected def save(GraphContainer gc, String fileName) {
 		val rs = new ResourceSetImpl
-		val uri = URI.createFileURI("./output/" + fileName + ".fsmgen2")
+		val uri = URI.createFileURI("./output/" + fileName + ".fsmgen")
 		val res = rs.createResource(uri)
 		res.contents.add(gc)
 		res.save(newHashMap)
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.xtend
new file mode 100644
index 000000000..ace7fa309
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.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:
+ * 		Henrik Rentz-Reichert (initial contribution)
+ * 
+ *******************************************************************************/
+
+package org.eclipse.etrice.core.genmodel.fsm.tests
+
+import org.eclipse.etrice.core.fsm.fSM.RefinedState
+import org.eclipse.etrice.core.fsm.util.FSMHelpers
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+import static org.junit.Assert.assertNull
+import static org.junit.Assert.assertTrue
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+
+class TestCodeInheritance extends FsmGenTestBase {
+	
+	GraphContainer gc
+	
+	extension FSMHelpers fsmHelpers = new FSMHelpers
+	
+	@Before
+	def void SetUp() {
+		gc = getGraphContainer("CodeInheritanceExample.room", "TestActor")
+		assertNotNull("graph context was created", gc)
+		
+		val logger = new NullLogger
+		FsmGenChecker.check(gc, logger)
+		assertFalse("logger has no errors", logger.hasErrors)
+		assertFalse("diagnostician has no errors", diagnostician.isFailed)
+	}
+	
+	@Test
+	def void testActionCodes_BaseEntryExit() {
+		val s = gc.graph.allStateNodes.findFirst[name.equals("BaseEntryExit")]
+		assertNotNull("state found", s)
+		assertTrue("refined state", s.stateGraphNode instanceof RefinedState)
+		val rs = s.stateGraphNode as RefinedState
+		assertEquals("entry code", "// derived entry\n", rs.entryCode.detailCode)
+		assertNull("exit code", rs.exitCode)
+		assertEquals("inherited entry", "// base entry\n", rs.inheritedEntryCode.detailCode)
+		assertEquals("inherited exit", "// base exit\n", rs.inheritedExitCode.detailCode)
+	}
+	
+	@Test
+	def void testActionCodes_Base() {
+		val s = gc.graph.allStateNodes.findFirst[name.equals("Base")]
+		assertNotNull("state found", s)
+		assertTrue("refined state", s.stateGraphNode instanceof RefinedState)
+		val rs = s.stateGraphNode as RefinedState
+		assertNull("entry code", rs.entryCode)
+		assertEquals("exit code", "// derived exit\n", rs.exitCode.detailCode)
+		assertEquals("inherited entry", "", rs.inheritedEntryCode.detailCode)
+		assertEquals("inherited exit", "", rs.inheritedExitCode.detailCode)
+	}
+	
+	@Test
+	def void testActionCodes_BaseSub() {
+		val s = gc.graph.allStateNodes.findFirst[name.equals("BaseSub")]
+		assertNotNull("state found", s)
+		assertTrue("refined state", s.stateGraphNode instanceof RefinedState)
+		val rs = s.stateGraphNode as RefinedState
+		assertEquals("entry code", "// derived entry\n", rs.entryCode.detailCode)
+		assertNull("exit code", rs.exitCode)
+		assertEquals("inherited entry", "", rs.inheritedEntryCode.detailCode)
+		assertEquals("inherited exit", "", rs.inheritedExitCode.detailCode)
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.xtend
index 977a8b0ea..977a8b0ea 100644
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.xtend
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.xtend
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.xtend
index fadf00a4d..fadf00a4d 100644
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.xtend
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.xtend
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.xtend
index db3793243..db3793243 100644
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.xtend
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.xtend
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.xtend
index 0392ef48c..bb12a3ab7 100644
--- a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/bin/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.xtend
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.xtend
@@ -12,6 +12,7 @@
 
 package org.eclipse.etrice.core.genmodel.fsm.tests
 
+import org.eclipse.emf.ecore.util.EcoreUtil
 import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
 import org.eclipse.etrice.core.genmodel.fsm.NullLogger
 import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
@@ -27,17 +28,21 @@ import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
 class TestHierInheritedFSM extends FsmGenTestBase {
 	
 	GraphContainer gc
+	GraphContainer gc2
 	
 	@Before
 	def void SetUp() {
 		gc = getGraphContainer("HierInheritedFSMExample.room", "TestActor")
+		gc2 = getGraphContainer("HierInheritedFSMExample.room", "TestActor2")
 		assertNotNull("graph context was created", gc)
+		assertNotNull("graph context was created", gc2)
 		
 		val logger = new NullLogger
 		FsmGenChecker.check(gc, logger)
 		assertFalse("logger has no errors", logger.hasErrors)
 		
 		save(gc, "HierInheritedFSMExample")
+		save(gc2, "HierInheritedFSMExample2")
 	}
 	
 	@Test
@@ -66,4 +71,16 @@ class TestHierInheritedFSM extends FsmGenTestBase {
 		assertEquals("incoming links", 2, s.incoming.size)
 		assertEquals("outgoing links", 1, s.outgoing.size)
 	}
+	
+	@Test
+	def void testOriginRefs() {
+		gc2.graph.nodes.filter[stateGraphNode.name == 'state0'] => [
+			assertEquals(1, size)
+			assertEquals('RefinedState:TestActor2$state0', EcoreUtil.getURI(head.stateGraphNode).fragment)
+		]
+		gc2.graph.links.filter[transition.name == 'tr3'] => [
+			assertEquals(1, size)
+			assertEquals('RefinedTransition:TestActor2$tr3', EcoreUtil.getURI(head.transition).fragment)
+		]
+	}
 }
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.xtend
new file mode 100644
index 000000000..613854ace
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.xtend
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * 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.tests
+
+import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition
+import org.eclipse.etrice.core.fsm.fSM.Transition
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.room.DataClass
+import org.eclipse.etrice.core.room.VarDecl
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+import static org.junit.Assert.assertTrue
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+
+class TestMultipleConnectedChoicepoint extends FsmGenTestBase {
+	
+	GraphContainer gc
+	
+	@Before
+	def void SetUp() {
+		gc = getGraphContainer("MultipleConnectedChoicepointExample.room", "TestActor")
+		assertNotNull("graph context was created", gc)
+		
+		val logger = new NullLogger
+		FsmGenChecker.check(gc, logger)
+		assertFalse("logger has no errors", logger.hasErrors)
+		
+		// enrich our generator model with all we have
+		gc.withTriggersInStates.withChainHeads.withCommonData
+		
+		assertFalse("diagnostician has no errors", diagnostician.isFailed)
+	}
+	
+	@Test
+	def void testObjectNumbers() {
+		assertEquals("Number of states", 6, gc.graph.allStateNodes.size)
+		assertEquals("Number of choice points", 1, gc.graph.allChoicePointNodes.size)
+		assertEquals("Number of transition points", 0, gc.graph.allTransitionPointNodes.size)
+		assertEquals("Number of entry points", 1, gc.graph.allEntryPointNodes.size)
+		assertEquals("Number of exit points", 1, gc.graph.allExitPointNodes.size)
+		assertEquals("Number of initial transitions", 1, gc.graph.allInitialTranisitionLinks.size)
+		assertEquals("Number of triggered transitions", 5, gc.graph.allTriggeredTranisitionLinks.size)
+		assertEquals("Number of continuation transitions", 3, gc.graph.allContinuationTranisitionLinks.size)
+		assertEquals("Number of cpbranch transitions", 1, gc.graph.allCPBranchTranisitionLinks.size)
+	}
+	
+	@Test
+	def void testChainsAndTriggers() {
+		assertEquals("transition chains", 6, gc.graph.getAllChainHeads.size)
+	}
+	
+	@Test
+	def void testData() {
+		var tr = gc.graph.links.filter[(transition as Transition).name.equals("tr0")].head
+		assertNotNull("transition found", tr)
+		assertTrue("transition is TriggeredTransition", tr.transition instanceof TriggeredTransition)
+		var data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC2", data.refType.type.name)
+		
+		val s = gc.graph.nodes.filter[stateGraphNode.name.equals("state1")].head
+		assertNotNull("state found", s)
+		
+		tr = s.subgraph.links.filter[(transition as Transition).name.equals("tr2")].head
+		assertTrue("transition is TriggeredTransition", tr.transition instanceof TriggeredTransition)
+		data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC2", data.refType.type.name)
+		
+		tr = s.subgraph.links.filter[(transition as Transition).name.equals("tr3")].head
+		assertTrue("transition is TriggeredTransition", tr.transition instanceof TriggeredTransition)
+		data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC4", data.refType.type.name)
+		
+ 		tr = gc.graph.links.filter[(transition as Transition).name.equals("tr1")].head
+		assertNotNull("transition found", tr)
+		assertTrue("transition is TriggeredTransition", tr.transition instanceof TriggeredTransition)
+		data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC3", data.refType.type.name)
+		
+ 		tr = gc.graph.links.filter[(transition as Transition).name.equals("tr3")].head
+		assertNotNull("transition found", tr)
+		assertTrue("transition is ContinuationTransition", tr.transition instanceof ContinuationTransition)
+		data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC", data.refType.type.name)
+		
+ 		tr = gc.graph.links.filter[(transition as Transition).name.equals("tr4")].head
+		assertNotNull("transition found", tr)
+		assertTrue("transition is CPBranchTransition", tr.transition instanceof CPBranchTransition)
+		data = tr.commonData as VarDecl
+		assertTrue("data is DataClass", data.refType.type instanceof DataClass)
+		assertEquals("data is of type", "DC", data.refType.type.name)
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.xtend
new file mode 100644
index 000000000..08a01feb0
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.xtend
@@ -0,0 +1,117 @@
+/*******************************************************************************
+ * 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.tests
+
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.naming.RoomNameProvider
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+import org.eclipse.etrice.core.fsm.fSM.Transition
+import org.eclipse.etrice.core.fsm.fSM.SimpleState
+
+class TestStatesInheritance extends FsmGenTestBase {
+	
+	RoomNameProvider roomNameProvider = new RoomNameProvider
+	
+	GraphContainer gc
+	
+	@Before
+	def void SetUp() {
+		gc = getGraphContainer("StatesInheritanceExample.room", "TestActor")
+		assertNotNull("graph context was created", gc)
+		
+		val logger = new NullLogger
+		FsmGenChecker.check(gc, logger)
+		assertFalse("logger has no errors", logger.hasErrors)
+		
+		// enrich our generator model with all we have
+		gc.withTriggersInStates.withChainHeads.withCommonData
+		
+		assertFalse("diagnostician has no errors", diagnostician.isFailed)
+	}
+	
+	@Test
+	def void testNoTrigger() {
+		val s = gc.graph.allStateNodes.filter[name.equals("State3")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("non-leave state has no caught triggers", 0, s.caughtTriggers.size)
+	}
+	
+	@Test
+	def void testObjectNumbers() {
+		assertEquals("Number of states", 11, gc.graph.allStateNodes.size)
+		assertEquals("Number of states", 9, gc.graph.allStateNodes.filter[stateGraphNode instanceof SimpleState].size)
+		assertEquals("Number of choice points", 1, gc.graph.allChoicePointNodes.size)
+		assertEquals("Number of transition points", 5, gc.graph.allTransitionPointNodes.size)
+		assertEquals("Number of entry points", 2, gc.graph.allEntryPointNodes.size)
+		assertEquals("Number of exit points", 1, gc.graph.allExitPointNodes.size)
+		assertEquals("Number of initial transitions", 3, gc.graph.allInitialTranisitionLinks.size)
+		assertEquals("Number of triggered transitions", 17, gc.graph.allTriggeredTranisitionLinks.size)
+		assertEquals("Number of continuation transitions", 4, gc.graph.allContinuationTranisitionLinks.size)
+		assertEquals("Number of cpbranch transitions", 3, gc.graph.allCPBranchTranisitionLinks.size)
+	}
+	
+	@Test
+	def void testChainsAndTriggers() {
+		assertEquals("transition chains", 20, gc.graph.getAllChainHeads.size)
+	}
+	
+	@Test
+	def void testGraph() {
+		var s = gc.graph.allStateNodes.filter[roomNameProvider.getFullPath(stateGraphNode).equals("State3_State3")].head
+		assertNotNull("state exists", s)
+		assertEquals("number of incoming transitions", 3, s.incoming.size)
+		assertEquals("number of outgoing transitions", 2, s.outgoing.size)
+		assertEquals("active triggers", 6, s.caughtTriggers.size)
+		
+		s = gc.graph.allStateNodes.filter[roomNameProvider.getFullPath(stateGraphNode).equals("State2")].head
+		assertNotNull("state exists", s)
+		assertEquals("number of incoming transitions", 4, s.incoming.size)
+		assertEquals("number of outgoing transitions", 1, s.outgoing.size)
+		assertEquals("active triggers", 3, s.caughtTriggers.size)
+		
+		val cp = gc.graph.allChoicePointNodes.filter[stateGraphNode.name.equals("CP1")].head
+		assertNotNull("cp exists", cp)
+		assertEquals("number of incoming transitions", 1, cp.incoming.size)
+		assertEquals("number of outgoing transitions", 4, cp.outgoing.size)
+		
+		val cts = cp.outgoing.filter[transition instanceof ContinuationTransition]
+		assertEquals("Exactly one continuation (=default) transition", 1, cts.size)
+	}
+	
+	@Test
+	def void testChains() {
+		var tr = gc.graph.allLinks.filter[roomNameProvider.getFullPath((transition as Transition)).equals("State3_TRANS_tr1_FROM_tp1_TO_State3")].head
+		assertNotNull("transition", tr)
+		
+		assertEquals("one chain head", 1, tr.chainHeads.size)
+		assertEquals("chain name", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", roomNameProvider.getFullPath(tr.chainHeads.head.transition as Transition))
+		
+		tr = gc.graph.allLinks.filter[roomNameProvider.getFullPath((transition as Transition)).equals("State3_TRANS_tr8_FROM_tp6_TO_State2")].head
+		assertNotNull("transition", tr)
+		
+		assertEquals("one chain head", 1, tr.chainHeads.size)
+		assertEquals("chain name", "TRANS_tr12_FROM_State5_TO_State3_tp6_BY_aport", roomNameProvider.getFullPath(tr.chainHeads.head.transition as Transition))
+		
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.xtend
new file mode 100644
index 000000000..7a1c204be
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.xtend
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * 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.tests
+
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.eclipse.etrice.core.naming.RoomNameProvider
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+import org.eclipse.etrice.core.fsm.fSM.Transition
+
+class TestStatesTriggers extends FsmGenTestBase {
+	
+	RoomNameProvider roomNameProvider = new RoomNameProvider
+	
+	GraphContainer gc
+	
+	@Before
+	def void SetUp() {
+		gc = getGraphContainer("StatesTriggersExample.room", "TestActor")
+		assertNotNull("graph context was created", gc)
+		
+		val logger = new NullLogger
+		FsmGenChecker.check(gc, logger)
+		assertFalse("logger has no errors", logger.hasErrors)
+		
+		// enrich our generator model with all we have
+		gc.withTriggersInStates.withChainHeads.withCommonData
+		
+		assertFalse("diagnostician has no errors", diagnostician.isFailed)
+	}
+	
+	@Test
+	def void testNoTrigger() {
+		val s = gc.graph.allStateNodes.filter[name.equals("State3")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("non-leave state has no caught triggers", 0, s.caughtTriggers.size)
+	}
+	
+	@Test
+	def void testObjectNumbers() {
+		assertEquals("Number of states", 7, gc.graph.allStateNodes.size)
+		assertEquals("Number of choice points", 1, gc.graph.allChoicePointNodes.size)
+		assertEquals("Number of transition points", 4, gc.graph.allTransitionPointNodes.size)
+		assertEquals("Number of entry points", 1, gc.graph.allEntryPointNodes.size)
+		assertEquals("Number of exit points", 1, gc.graph.allExitPointNodes.size)
+		assertEquals("Number of initial transitions", 2, gc.graph.allInitialTranisitionLinks.size)
+		assertEquals("Number of triggered transitions", 11, gc.graph.allTriggeredTranisitionLinks.size)
+		assertEquals("Number of continuation transitions", 3, gc.graph.allContinuationTranisitionLinks.size)
+		assertEquals("Number of cpbranch transitions", 2, gc.graph.allCPBranchTranisitionLinks.size)
+	}
+	
+	@Test
+	def void testChainsAndTriggers() {
+		assertEquals("transition chains", 13, gc.graph.getAllChainHeads.size)
+	}
+	
+	@Test
+	def void testGraph() {
+		var s = gc.graph.nodes.filter[name.equals("State3")].head
+		s = s.subgraph.nodes.filter[name.equals("State3")].head
+		assertNotNull("state found", s)
+		assertEquals("number of incoming transitions", 3, s.incoming.size);
+		assertEquals("number of outgoing transitions", 2, s.outgoing.size);
+		assertEquals("active triggers", 6, s.caughtTriggers.size);
+		
+		s = gc.graph.nodes.filter[name.equals("State2")].head
+		assertNotNull("state found", s)
+		assertEquals("number of incoming transitions", 4, s.incoming.size);
+		assertEquals("number of outgoing transitions", 1, s.outgoing.size);
+		assertEquals("active triggers", 3, s.caughtTriggers.size);
+		
+		val cp = gc.graph.nodes.filter[name.equals("CP1")].head
+		assertNotNull("cp found", cp)
+		assertEquals("number of incoming transitions", 1, cp.incoming.size);
+		assertEquals("number of outgoing transitions", 3, cp.outgoing.size);
+		
+		val cts = cp.outgoing.filter[transition instanceof ContinuationTransition]
+		assertEquals("Exactly one continuation (=default) transition", 1, cts.size)
+	}
+	
+	@Test
+	def void testChains() {
+		val tr = gc.graph.allLinks.filter[roomNameProvider.getFullPath((transition as Transition)).equals("State3_TRANS_tr1_FROM_tp1_TO_State3")].head
+		assertNotNull("transition found", tr)
+		assertEquals("one chain head", 1, tr.chainHeads.size)
+		assertEquals("correct chain head", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", roomNameProvider.getFullPath((tr.chainHeads.head.transition as Transition)))
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.xtend b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.xtend
new file mode 100644
index 000000000..13831a137
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/src/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.xtend
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * 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.tests
+
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger
+import org.eclipse.etrice.core.genmodel.fsm.TriggerExtensions
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+
+import static extension org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions.*
+
+class TestTrigger extends FsmGenTestBase {
+	
+	GraphContainer gc
+	
+	@Before
+	def void SetUp() {
+		gc = getGraphContainer("TriggerExample.room", "TestActor")
+		assertNotNull("graph context was created", gc)
+		
+		val logger = new NullLogger
+		FsmGenChecker.check(gc, logger)
+		assertFalse("logger has no errors", logger.hasErrors)
+		
+		gc.withTriggersInStates
+		assertFalse("diagnostician has no errors", diagnostician.isFailed)
+		val s = gc.graph.allStateNodes.filter[name.equals("state0_0")].head
+		assertEquals("leave state triggers", 3, s.caughtTriggers.size)
+	}
+	
+	@Test
+	def void testNoTrigger() {
+		val s = gc.graph.allStateNodes.filter[name.equals("state0")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("non-leave state has no caught triggers", 0, s.caughtTriggers.size)
+	}
+	
+	@Test
+	def void testTrigger_state0_0() {
+		val s = gc.graph.allStateNodes.filter[name.equals("state0_0")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("leave state triggers", 3, s.caughtTriggers.size)
+		
+		assertEquals("1st trigger", "in3".trigger , s.caughtTriggers.get(0).trigger)
+		assertEquals("1st trigger, transitions", 1, s.caughtTriggers.get(0).links.size)
+		assertEquals("2nd trigger", "in1".trigger , s.caughtTriggers.get(1).trigger)
+		assertEquals("2nd trigger, transitions", 1, s.caughtTriggers.get(1).links.size)
+		assertEquals("3rd trigger", "in2".trigger , s.caughtTriggers.get(2).trigger)
+		assertEquals("3rd trigger, transitions", 1, s.caughtTriggers.get(2).links.size)
+	}
+	
+	@Test
+	def void testTrigger_state0_1() {
+		val s = gc.graph.allStateNodes.filter[name.equals("state0_1")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("leave state triggers", 2, s.caughtTriggers.size)
+		
+		assertEquals("1st trigger", "in2".trigger , s.caughtTriggers.get(0).trigger)
+		assertEquals("1st trigger, transitions", 1, s.caughtTriggers.get(0).links.size)
+		assertEquals("2nd trigger", "in1".trigger , s.caughtTriggers.get(1).trigger)
+		assertEquals("2nd trigger, transitions", 1, s.caughtTriggers.get(1).links.size)
+	}
+	
+	@Test
+	def void testTrigger_state1_0() {
+		val s = gc.graph.allStateNodes.filter[name.equals("state1_0")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("leave state triggers", 2, s.caughtTriggers.size)
+		
+		assertEquals("1st trigger", "in1".trigger , s.caughtTriggers.get(0).trigger)
+		// note: the transition in the sub graph is unguarded and hides the top level one
+		assertEquals("1st trigger, transitions", 1, s.caughtTriggers.get(0).links.size)
+		assertEquals("2nd trigger", "in2".trigger , s.caughtTriggers.get(1).trigger)
+		assertEquals("2nd trigger, transitions", 1, s.caughtTriggers.get(1).links.size)
+	}
+	
+	@Test
+	def void testTrigger_state1_1() {
+		val s = gc.graph.allStateNodes.filter[name.equals("state1_1")].head
+		assertNotNull("state found", s)
+		
+		assertEquals("leave state triggers", 2, s.caughtTriggers.size)
+		
+		assertEquals("1st trigger", "in1".trigger , s.caughtTriggers.get(0).trigger)
+		// note: the transition in the sub graph is guarded and two top level ones are also added
+		assertEquals("1st trigger, transitions", 3, s.caughtTriggers.get(0).links.size)
+		assertEquals("2nd trigger", "in2".trigger , s.caughtTriggers.get(1).trigger)
+		assertEquals("2nd trigger, transitions", 1, s.caughtTriggers.get(1).links.size)
+	}
+	
+	def trigger(String msg) {
+		"p0" + TriggerExtensions.TRIGGER_SEP + msg
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.java
new file mode 100644
index 000000000..0198fb95c
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/FsmGenTestBase.java
@@ -0,0 +1,76 @@
+/**
+ * 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.tests;
+
+import com.google.inject.Injector;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.etrice.core.RoomStandaloneSetup;
+import org.eclipse.etrice.core.TestBase;
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.NullDiagnostician;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FSMGenModelTestsActivator;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class FsmGenTestBase extends TestBase {
+  protected Resource res = null;
+  
+  protected ActorClass actor;
+  
+  protected IDiagnostician diagnostician = new NullDiagnostician();
+  
+  @Extension
+  protected ExtendedFsmGenBuilder builder;
+  
+  protected GraphContainer getGraphContainer(final String roomFile, final String actorName) {
+    GraphContainer _xblockexpression = null;
+    {
+      this.prepare(FSMGenModelTestsActivator.getInstance().getBundle());
+      this.res = this.getResource(roomFile);
+      EObject _get = this.res.getContents().get(0);
+      final Function1<ActorClass, Boolean> _function = new Function1<ActorClass, Boolean>() {
+        @Override
+        public Boolean apply(final ActorClass it) {
+          return Boolean.valueOf(it.getName().equals(actorName));
+        }
+      };
+      this.actor = IterableExtensions.<ActorClass>findFirst(((RoomModel) _get).getActorClasses(), _function);
+      final Injector injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration();
+      ExtendedFsmGenBuilder _extendedFsmGenBuilder = new ExtendedFsmGenBuilder(injector, this.diagnostician);
+      this.builder = _extendedFsmGenBuilder;
+      _xblockexpression = this.builder.createTransformedModel(this.actor);
+    }
+    return _xblockexpression;
+  }
+  
+  protected void save(final GraphContainer gc, final String fileName) {
+    try {
+      final ResourceSetImpl rs = new ResourceSetImpl();
+      final URI uri = URI.createFileURI((("./output/" + fileName) + ".fsmgen"));
+      final Resource res = rs.createResource(uri);
+      res.getContents().add(gc);
+      res.save(CollectionLiterals.<Object, Object>newHashMap());
+    } catch (Throwable _e) {
+      throw Exceptions.sneakyThrow(_e);
+    }
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.java
new file mode 100644
index 000000000..c1ffb81b2
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestCodeInheritance.java
@@ -0,0 +1,105 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.RefinedState;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.util.FSMHelpers;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestCodeInheritance extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Extension
+  private FSMHelpers fsmHelpers = new FSMHelpers();
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("CodeInheritanceExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    Assert.assertFalse("diagnostician has no errors", this.diagnostician.isFailed());
+  }
+  
+  @Test
+  public void testActionCodes_BaseEntryExit() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("BaseEntryExit"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>findFirst(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function);
+    Assert.assertNotNull("state found", s);
+    StateGraphNode _stateGraphNode = s.getStateGraphNode();
+    Assert.assertTrue("refined state", (_stateGraphNode instanceof RefinedState));
+    StateGraphNode _stateGraphNode_1 = s.getStateGraphNode();
+    final RefinedState rs = ((RefinedState) _stateGraphNode_1);
+    Assert.assertEquals("entry code", "// derived entry\n", this.fsmHelpers.getDetailCode(rs.getEntryCode()));
+    Assert.assertNull("exit code", rs.getExitCode());
+    Assert.assertEquals("inherited entry", "// base entry\n", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedEntryCode(rs)));
+    Assert.assertEquals("inherited exit", "// base exit\n", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedExitCode(rs)));
+  }
+  
+  @Test
+  public void testActionCodes_Base() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("Base"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>findFirst(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function);
+    Assert.assertNotNull("state found", s);
+    StateGraphNode _stateGraphNode = s.getStateGraphNode();
+    Assert.assertTrue("refined state", (_stateGraphNode instanceof RefinedState));
+    StateGraphNode _stateGraphNode_1 = s.getStateGraphNode();
+    final RefinedState rs = ((RefinedState) _stateGraphNode_1);
+    Assert.assertNull("entry code", rs.getEntryCode());
+    Assert.assertEquals("exit code", "// derived exit\n", this.fsmHelpers.getDetailCode(rs.getExitCode()));
+    Assert.assertEquals("inherited entry", "", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedEntryCode(rs)));
+    Assert.assertEquals("inherited exit", "", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedExitCode(rs)));
+  }
+  
+  @Test
+  public void testActionCodes_BaseSub() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("BaseSub"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>findFirst(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function);
+    Assert.assertNotNull("state found", s);
+    StateGraphNode _stateGraphNode = s.getStateGraphNode();
+    Assert.assertTrue("refined state", (_stateGraphNode instanceof RefinedState));
+    StateGraphNode _stateGraphNode_1 = s.getStateGraphNode();
+    final RefinedState rs = ((RefinedState) _stateGraphNode_1);
+    Assert.assertEquals("entry code", "// derived entry\n", this.fsmHelpers.getDetailCode(rs.getEntryCode()));
+    Assert.assertNull("exit code", rs.getExitCode());
+    Assert.assertEquals("inherited entry", "", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedEntryCode(rs)));
+    Assert.assertEquals("inherited exit", "", this.fsmHelpers.getDetailCode(this.fsmHelpers.getInheritedExitCode(rs)));
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.java
new file mode 100644
index 000000000..fc6734787
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatFSM.java
@@ -0,0 +1,113 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
+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.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestFlatFSM extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("FlatFSMExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+  }
+  
+  @Test
+  public void testFlatFSMItemCounts() {
+    Assert.assertEquals("number of nodes", 6, this.gc.getGraph().getNodes().size());
+    Assert.assertEquals("number of links", 6, this.gc.getGraph().getLinks().size());
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof State));
+      }
+    };
+    Assert.assertEquals("number of states", 4, IterableExtensions.size(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function)));
+    final Function1<Node, Boolean> _function_1 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof TrPoint));
+      }
+    };
+    Assert.assertEquals("number of tr points", 1, IterableExtensions.size(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function_1)));
+    final Function1<Node, Boolean> _function_2 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof ChoicePoint));
+      }
+    };
+    Assert.assertEquals("number of choice points", 1, IterableExtensions.size(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function_2)));
+  }
+  
+  @Test
+  public void testFlatFSMState1Connections() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1"));
+      }
+    };
+    final Node s1 = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s1);
+    Assert.assertEquals("incoming links", 1, s1.getIncoming().size());
+    Assert.assertEquals("outgoing links", 1, s1.getOutgoing().size());
+  }
+  
+  @Test
+  public void testFlatFSMState3Connections() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state3"));
+      }
+    };
+    final Node s3 = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s3);
+    Assert.assertEquals("incoming links", 1, s3.getIncoming().size());
+    Assert.assertEquals("outgoing links", 0, s3.getOutgoing().size());
+  }
+  
+  @Test
+  public void testFlatFSMCPConnections() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("cp0"));
+      }
+    };
+    final Node cp = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getChoicePointNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("choice point found", cp);
+    Assert.assertEquals("incoming links", 1, cp.getIncoming().size());
+    Assert.assertEquals("outgoing links", 2, cp.getOutgoing().size());
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.java
new file mode 100644
index 000000000..8fbd53473
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestFlatInheritedFSM.java
@@ -0,0 +1,86 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.RefinedState;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestFlatInheritedFSM extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("FlatInheritedFSMExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+  }
+  
+  @Test
+  public void testFlatInheritedFSMItemCounts() {
+    Assert.assertEquals("number of nodes", 6, this.gc.getGraph().getNodes().size());
+    Assert.assertEquals("number of links", 6, this.gc.getGraph().getLinks().size());
+    Assert.assertEquals("number of states", 6, IterableExtensions.size(FsmGenExtensions.getStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of tr points", 0, IterableExtensions.size(FsmGenExtensions.getTrPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of choice points", 0, IterableExtensions.size(FsmGenExtensions.getChoicePointNodes(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testFlatInheritedFSMState0Connections() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state0"));
+      }
+    };
+    final Node s = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("incoming links", 1, s.getIncoming().size());
+    Assert.assertEquals("outgoing links", 1, s.getOutgoing().size());
+  }
+  
+  @Test
+  public void testHierFSMPointersIntoOriginalFSM() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1"));
+      }
+    };
+    final Node n = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function));
+    final Function1<State, Boolean> _function_1 = new Function1<State, Boolean>() {
+      @Override
+      public Boolean apply(final State it) {
+        return Boolean.valueOf(it.getName().equals("state1"));
+      }
+    };
+    final State s = IterableExtensions.<State>head(IterableExtensions.<State>filter(this.actor.getStateMachine().getStates(), _function_1));
+    Assert.assertNotNull("node found", n);
+    Assert.assertNotNull("state found", s);
+    StateGraphNode _stateGraphNode = n.getStateGraphNode();
+    Assert.assertTrue("RefinedState expected", (_stateGraphNode instanceof RefinedState));
+    Assert.assertEquals("correct target", s, n.getStateGraphNode());
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.java
new file mode 100644
index 000000000..64b14a66c
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierFSM.java
@@ -0,0 +1,110 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.SimpleState;
+import org.eclipse.etrice.core.fsm.fSM.State;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger;
+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.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestHierFSM extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("HierFSMExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+  }
+  
+  @Test
+  public void testHierFSMItemCounts() {
+    Assert.assertEquals("number of nodes", 3, this.gc.getGraph().getNodes().size());
+    Assert.assertEquals("number of links", 4, this.gc.getGraph().getLinks().size());
+    Assert.assertEquals("number of states", 3, IterableExtensions.size(FsmGenExtensions.getStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of tr points", 0, IterableExtensions.size(FsmGenExtensions.getTrPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of choice points", 0, IterableExtensions.size(FsmGenExtensions.getChoicePointNodes(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testHierFSMSubGraphItemCounts() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1"));
+      }
+    };
+    final Graph subGraph = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function)).getSubgraph();
+    Assert.assertEquals("number of nodes", 4, subGraph.getNodes().size());
+    Assert.assertEquals("number of links", 4, subGraph.getLinks().size());
+    Assert.assertEquals("number of states", 2, IterableExtensions.size(FsmGenExtensions.getStateNodes(subGraph)));
+    Assert.assertEquals("number of tr points", 2, IterableExtensions.size(FsmGenExtensions.getTrPointNodes(subGraph)));
+    Assert.assertEquals("number of choice points", 0, IterableExtensions.size(FsmGenExtensions.getChoicePointNodes(subGraph)));
+  }
+  
+  @Test
+  public void testHierFSMState1_1Connections() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1"));
+      }
+    };
+    final Graph subGraph = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function)).getSubgraph();
+    final Function1<Node, Boolean> _function_1 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1_1"));
+      }
+    };
+    final Node s1_1 = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(subGraph), _function_1));
+    Assert.assertNotNull("state found", s1_1);
+    Assert.assertEquals("incoming links", 2, s1_1.getIncoming().size());
+    Assert.assertEquals("outgoing links", 1, s1_1.getOutgoing().size());
+  }
+  
+  @Test
+  public void testHierFSMPointersIntoOriginalFSM() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1"));
+      }
+    };
+    final Node n = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(FsmGenExtensions.getStateNodes(this.gc.getGraph()), _function));
+    final Function1<State, Boolean> _function_1 = new Function1<State, Boolean>() {
+      @Override
+      public Boolean apply(final State it) {
+        return Boolean.valueOf(it.getName().equals("state1"));
+      }
+    };
+    final State s = IterableExtensions.<State>head(IterableExtensions.<State>filter(this.actor.getStateMachine().getStates(), _function_1));
+    Assert.assertNotNull("node found", n);
+    Assert.assertNotNull("state found", s);
+    StateGraphNode _stateGraphNode = n.getStateGraphNode();
+    Assert.assertTrue("State expected", (_stateGraphNode instanceof SimpleState));
+    Assert.assertEquals("correct target", s, n.getStateGraphNode());
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.java
new file mode 100644
index 000000000..466923419
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestHierInheritedFSM.java
@@ -0,0 +1,117 @@
+/**
+ * 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.tests;
+
+import com.google.common.base.Objects;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestHierInheritedFSM extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  private GraphContainer gc2;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("HierInheritedFSMExample.room", "TestActor");
+    this.gc2 = this.getGraphContainer("HierInheritedFSMExample.room", "TestActor2");
+    Assert.assertNotNull("graph context was created", this.gc);
+    Assert.assertNotNull("graph context was created", this.gc2);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    this.save(this.gc, "HierInheritedFSMExample");
+    this.save(this.gc2, "HierInheritedFSMExample2");
+  }
+  
+  @Test
+  public void testHierInheritedFSMItemCounts() {
+    Assert.assertEquals("number of nodes", 4, this.gc.getGraph().getNodes().size());
+    Assert.assertEquals("number of links", 6, this.gc.getGraph().getLinks().size());
+    Assert.assertEquals("number of states", 4, IterableExtensions.size(FsmGenExtensions.getStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of tr points", 0, IterableExtensions.size(FsmGenExtensions.getTrPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of choice points", 0, IterableExtensions.size(FsmGenExtensions.getChoicePointNodes(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testHierInheritedFSMDeepItemCounts() {
+    Assert.assertEquals("number of nodes", 12, IteratorExtensions.size(FsmGenExtensions.getAllNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of links", 14, IteratorExtensions.size(FsmGenExtensions.getAllLinks(this.gc.getGraph())));
+    Assert.assertEquals("number of states", 10, IteratorExtensions.size(FsmGenExtensions.getAllStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of tr points", 2, IteratorExtensions.size(FsmGenExtensions.getAllTrPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("number of choice points", 0, IteratorExtensions.size(FsmGenExtensions.getAllChoicePointNodes(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testHierInheritedFSMLinks() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1_0"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("incoming links", 2, s.getIncoming().size());
+    Assert.assertEquals("outgoing links", 1, s.getOutgoing().size());
+  }
+  
+  @Test
+  public void testOriginRefs() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        String _name = it.getStateGraphNode().getName();
+        return Boolean.valueOf(Objects.equal(_name, "state0"));
+      }
+    };
+    Iterable<Node> _filter = IterableExtensions.<Node>filter(this.gc2.getGraph().getNodes(), _function);
+    final Procedure1<Iterable<Node>> _function_1 = new Procedure1<Iterable<Node>>() {
+      @Override
+      public void apply(final Iterable<Node> it) {
+        Assert.assertEquals(1, IterableExtensions.size(it));
+        Assert.assertEquals("RefinedState:TestActor2$state0", EcoreUtil.getURI(IterableExtensions.<Node>head(it).getStateGraphNode()).fragment());
+      }
+    };
+    ObjectExtensions.<Iterable<Node>>operator_doubleArrow(_filter, _function_1);
+    final Function1<Link, Boolean> _function_2 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        String _name = it.getTransition().getName();
+        return Boolean.valueOf(Objects.equal(_name, "tr3"));
+      }
+    };
+    Iterable<Link> _filter_1 = IterableExtensions.<Link>filter(this.gc2.getGraph().getLinks(), _function_2);
+    final Procedure1<Iterable<Link>> _function_3 = new Procedure1<Iterable<Link>>() {
+      @Override
+      public void apply(final Iterable<Link> it) {
+        Assert.assertEquals(1, IterableExtensions.size(it));
+        Assert.assertEquals("RefinedTransition:TestActor2$tr3", EcoreUtil.getURI(IterableExtensions.<Link>head(it).getTransition()).fragment());
+      }
+    };
+    ObjectExtensions.<Iterable<Link>>operator_doubleArrow(_filter_1, _function_3);
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.java
new file mode 100644
index 000000000..27cf9e006
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestMultipleConnectedChoicepoint.java
@@ -0,0 +1,174 @@
+/**
+ * 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.tests;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.fsm.fSM.CPBranchTransition;
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestMultipleConnectedChoicepoint extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("MultipleConnectedChoicepointExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    this.builder.withCommonData(this.builder.withChainHeads(this.builder.withTriggersInStates(this.gc)));
+    Assert.assertFalse("diagnostician has no errors", this.diagnostician.isFailed());
+  }
+  
+  @Test
+  public void testObjectNumbers() {
+    Assert.assertEquals("Number of states", 6, IteratorExtensions.size(FsmGenExtensions.getAllStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of choice points", 1, IteratorExtensions.size(FsmGenExtensions.getAllChoicePointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of transition points", 0, IteratorExtensions.size(FsmGenExtensions.getAllTransitionPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of entry points", 1, IteratorExtensions.size(FsmGenExtensions.getAllEntryPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of exit points", 1, IteratorExtensions.size(FsmGenExtensions.getAllExitPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of initial transitions", 1, IteratorExtensions.size(FsmGenExtensions.getAllInitialTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of triggered transitions", 5, IteratorExtensions.size(FsmGenExtensions.getAllTriggeredTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of continuation transitions", 3, IteratorExtensions.size(FsmGenExtensions.getAllContinuationTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of cpbranch transitions", 1, IteratorExtensions.size(FsmGenExtensions.getAllCPBranchTranisitionLinks(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testChainsAndTriggers() {
+    Assert.assertEquals("transition chains", 6, IteratorExtensions.size(FsmGenExtensions.getAllChainHeads(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testData() {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr0"));
+      }
+    };
+    Link tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(this.gc.getGraph().getLinks(), _function));
+    Assert.assertNotNull("transition found", tr);
+    TransitionBase _transition = tr.getTransition();
+    Assert.assertTrue("transition is TriggeredTransition", (_transition instanceof TriggeredTransition));
+    EObject _commonData = tr.getCommonData();
+    VarDecl data = ((VarDecl) _commonData);
+    DataType _type = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC2", data.getRefType().getType().getName());
+    final Function1<Node, Boolean> _function_1 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(it.getStateGraphNode().getName().equals("state1"));
+      }
+    };
+    final Node s = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function_1));
+    Assert.assertNotNull("state found", s);
+    final Function1<Link, Boolean> _function_2 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr2"));
+      }
+    };
+    tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(s.getSubgraph().getLinks(), _function_2));
+    TransitionBase _transition_1 = tr.getTransition();
+    Assert.assertTrue("transition is TriggeredTransition", (_transition_1 instanceof TriggeredTransition));
+    EObject _commonData_1 = tr.getCommonData();
+    data = ((VarDecl) _commonData_1);
+    DataType _type_1 = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type_1 instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC2", data.getRefType().getType().getName());
+    final Function1<Link, Boolean> _function_3 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr3"));
+      }
+    };
+    tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(s.getSubgraph().getLinks(), _function_3));
+    TransitionBase _transition_2 = tr.getTransition();
+    Assert.assertTrue("transition is TriggeredTransition", (_transition_2 instanceof TriggeredTransition));
+    EObject _commonData_2 = tr.getCommonData();
+    data = ((VarDecl) _commonData_2);
+    DataType _type_2 = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type_2 instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC4", data.getRefType().getType().getName());
+    final Function1<Link, Boolean> _function_4 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr1"));
+      }
+    };
+    tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(this.gc.getGraph().getLinks(), _function_4));
+    Assert.assertNotNull("transition found", tr);
+    TransitionBase _transition_3 = tr.getTransition();
+    Assert.assertTrue("transition is TriggeredTransition", (_transition_3 instanceof TriggeredTransition));
+    EObject _commonData_3 = tr.getCommonData();
+    data = ((VarDecl) _commonData_3);
+    DataType _type_3 = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type_3 instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC3", data.getRefType().getType().getName());
+    final Function1<Link, Boolean> _function_5 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr3"));
+      }
+    };
+    tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(this.gc.getGraph().getLinks(), _function_5));
+    Assert.assertNotNull("transition found", tr);
+    TransitionBase _transition_4 = tr.getTransition();
+    Assert.assertTrue("transition is ContinuationTransition", (_transition_4 instanceof ContinuationTransition));
+    EObject _commonData_4 = tr.getCommonData();
+    data = ((VarDecl) _commonData_4);
+    DataType _type_4 = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type_4 instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC", data.getRefType().getType().getName());
+    final Function1<Link, Boolean> _function_6 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(((Transition) _transition).getName().equals("tr4"));
+      }
+    };
+    tr = IterableExtensions.<Link>head(IterableExtensions.<Link>filter(this.gc.getGraph().getLinks(), _function_6));
+    Assert.assertNotNull("transition found", tr);
+    TransitionBase _transition_5 = tr.getTransition();
+    Assert.assertTrue("transition is CPBranchTransition", (_transition_5 instanceof CPBranchTransition));
+    EObject _commonData_5 = tr.getCommonData();
+    data = ((VarDecl) _commonData_5);
+    DataType _type_5 = data.getRefType().getType();
+    Assert.assertTrue("data is DataClass", (_type_5 instanceof DataClass));
+    Assert.assertEquals("data is of type", "DC", data.getRefType().getType().getName());
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.java
new file mode 100644
index 000000000..099db3f80
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesInheritance.java
@@ -0,0 +1,161 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
+import org.eclipse.etrice.core.fsm.fSM.SimpleState;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.etrice.core.naming.RoomNameProvider;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestStatesInheritance extends FsmGenTestBase {
+  private RoomNameProvider roomNameProvider = new RoomNameProvider();
+  
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("StatesInheritanceExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    this.builder.withCommonData(this.builder.withChainHeads(this.builder.withTriggersInStates(this.gc)));
+    Assert.assertFalse("diagnostician has no errors", this.diagnostician.isFailed());
+  }
+  
+  @Test
+  public void testNoTrigger() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("State3"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("non-leave state has no caught triggers", 0, s.getCaughtTriggers().size());
+  }
+  
+  @Test
+  public void testObjectNumbers() {
+    Assert.assertEquals("Number of states", 11, IteratorExtensions.size(FsmGenExtensions.getAllStateNodes(this.gc.getGraph())));
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        StateGraphNode _stateGraphNode = it.getStateGraphNode();
+        return Boolean.valueOf((_stateGraphNode instanceof SimpleState));
+      }
+    };
+    Assert.assertEquals("Number of states", 9, IteratorExtensions.size(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function)));
+    Assert.assertEquals("Number of choice points", 1, IteratorExtensions.size(FsmGenExtensions.getAllChoicePointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of transition points", 5, IteratorExtensions.size(FsmGenExtensions.getAllTransitionPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of entry points", 2, IteratorExtensions.size(FsmGenExtensions.getAllEntryPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of exit points", 1, IteratorExtensions.size(FsmGenExtensions.getAllExitPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of initial transitions", 3, IteratorExtensions.size(FsmGenExtensions.getAllInitialTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of triggered transitions", 17, IteratorExtensions.size(FsmGenExtensions.getAllTriggeredTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of continuation transitions", 4, IteratorExtensions.size(FsmGenExtensions.getAllContinuationTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of cpbranch transitions", 3, IteratorExtensions.size(FsmGenExtensions.getAllCPBranchTranisitionLinks(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testChainsAndTriggers() {
+    Assert.assertEquals("transition chains", 20, IteratorExtensions.size(FsmGenExtensions.getAllChainHeads(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testGraph() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(TestStatesInheritance.this.roomNameProvider.getFullPath(it.getStateGraphNode()).equals("State3_State3"));
+      }
+    };
+    Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state exists", s);
+    Assert.assertEquals("number of incoming transitions", 3, s.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 2, s.getOutgoing().size());
+    Assert.assertEquals("active triggers", 6, s.getCaughtTriggers().size());
+    final Function1<Node, Boolean> _function_1 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(TestStatesInheritance.this.roomNameProvider.getFullPath(it.getStateGraphNode()).equals("State2"));
+      }
+    };
+    s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function_1));
+    Assert.assertNotNull("state exists", s);
+    Assert.assertEquals("number of incoming transitions", 4, s.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 1, s.getOutgoing().size());
+    Assert.assertEquals("active triggers", 3, s.getCaughtTriggers().size());
+    final Function1<Node, Boolean> _function_2 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(it.getStateGraphNode().getName().equals("CP1"));
+      }
+    };
+    final Node cp = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllChoicePointNodes(this.gc.getGraph()), _function_2));
+    Assert.assertNotNull("cp exists", cp);
+    Assert.assertEquals("number of incoming transitions", 1, cp.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 4, cp.getOutgoing().size());
+    final Function1<Link, Boolean> _function_3 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof ContinuationTransition));
+      }
+    };
+    final Iterable<Link> cts = IterableExtensions.<Link>filter(cp.getOutgoing(), _function_3);
+    Assert.assertEquals("Exactly one continuation (=default) transition", 1, IterableExtensions.size(cts));
+  }
+  
+  @Test
+  public void testChains() {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(TestStatesInheritance.this.roomNameProvider.getFullPath(((Transition) _transition)).equals("State3_TRANS_tr1_FROM_tp1_TO_State3"));
+      }
+    };
+    Link tr = IteratorExtensions.<Link>head(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(this.gc.getGraph()), _function));
+    Assert.assertNotNull("transition", tr);
+    Assert.assertEquals("one chain head", 1, tr.getChainHeads().size());
+    TransitionBase _transition = IterableExtensions.<Link>head(tr.getChainHeads()).getTransition();
+    Assert.assertEquals("chain name", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", this.roomNameProvider.getFullPath(((Transition) _transition)));
+    final Function1<Link, Boolean> _function_1 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(TestStatesInheritance.this.roomNameProvider.getFullPath(((Transition) _transition)).equals("State3_TRANS_tr8_FROM_tp6_TO_State2"));
+      }
+    };
+    tr = IteratorExtensions.<Link>head(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(this.gc.getGraph()), _function_1));
+    Assert.assertNotNull("transition", tr);
+    Assert.assertEquals("one chain head", 1, tr.getChainHeads().size());
+    TransitionBase _transition_1 = IterableExtensions.<Link>head(tr.getChainHeads()).getTransition();
+    Assert.assertEquals("chain name", "TRANS_tr12_FROM_State5_TO_State3_tp6_BY_aport", this.roomNameProvider.getFullPath(((Transition) _transition_1)));
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.java
new file mode 100644
index 000000000..ee2c0d9f7
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestStatesTriggers.java
@@ -0,0 +1,146 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
+import org.eclipse.etrice.core.fsm.fSM.Transition;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+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.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.etrice.core.naming.RoomNameProvider;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestStatesTriggers extends FsmGenTestBase {
+  private RoomNameProvider roomNameProvider = new RoomNameProvider();
+  
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("StatesTriggersExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    this.builder.withCommonData(this.builder.withChainHeads(this.builder.withTriggersInStates(this.gc)));
+    Assert.assertFalse("diagnostician has no errors", this.diagnostician.isFailed());
+  }
+  
+  @Test
+  public void testNoTrigger() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("State3"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("non-leave state has no caught triggers", 0, s.getCaughtTriggers().size());
+  }
+  
+  @Test
+  public void testObjectNumbers() {
+    Assert.assertEquals("Number of states", 7, IteratorExtensions.size(FsmGenExtensions.getAllStateNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of choice points", 1, IteratorExtensions.size(FsmGenExtensions.getAllChoicePointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of transition points", 4, IteratorExtensions.size(FsmGenExtensions.getAllTransitionPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of entry points", 1, IteratorExtensions.size(FsmGenExtensions.getAllEntryPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of exit points", 1, IteratorExtensions.size(FsmGenExtensions.getAllExitPointNodes(this.gc.getGraph())));
+    Assert.assertEquals("Number of initial transitions", 2, IteratorExtensions.size(FsmGenExtensions.getAllInitialTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of triggered transitions", 11, IteratorExtensions.size(FsmGenExtensions.getAllTriggeredTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of continuation transitions", 3, IteratorExtensions.size(FsmGenExtensions.getAllContinuationTranisitionLinks(this.gc.getGraph())));
+    Assert.assertEquals("Number of cpbranch transitions", 2, IteratorExtensions.size(FsmGenExtensions.getAllCPBranchTranisitionLinks(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testChainsAndTriggers() {
+    Assert.assertEquals("transition chains", 13, IteratorExtensions.size(FsmGenExtensions.getAllChainHeads(this.gc.getGraph())));
+  }
+  
+  @Test
+  public void testGraph() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("State3"));
+      }
+    };
+    Node s = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function));
+    final Function1<Node, Boolean> _function_1 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("State3"));
+      }
+    };
+    s = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(s.getSubgraph().getNodes(), _function_1));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("number of incoming transitions", 3, s.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 2, s.getOutgoing().size());
+    Assert.assertEquals("active triggers", 6, s.getCaughtTriggers().size());
+    final Function1<Node, Boolean> _function_2 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("State2"));
+      }
+    };
+    s = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function_2));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("number of incoming transitions", 4, s.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 1, s.getOutgoing().size());
+    Assert.assertEquals("active triggers", 3, s.getCaughtTriggers().size());
+    final Function1<Node, Boolean> _function_3 = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("CP1"));
+      }
+    };
+    final Node cp = IterableExtensions.<Node>head(IterableExtensions.<Node>filter(this.gc.getGraph().getNodes(), _function_3));
+    Assert.assertNotNull("cp found", cp);
+    Assert.assertEquals("number of incoming transitions", 1, cp.getIncoming().size());
+    Assert.assertEquals("number of outgoing transitions", 3, cp.getOutgoing().size());
+    final Function1<Link, Boolean> _function_4 = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf((_transition instanceof ContinuationTransition));
+      }
+    };
+    final Iterable<Link> cts = IterableExtensions.<Link>filter(cp.getOutgoing(), _function_4);
+    Assert.assertEquals("Exactly one continuation (=default) transition", 1, IterableExtensions.size(cts));
+  }
+  
+  @Test
+  public void testChains() {
+    final Function1<Link, Boolean> _function = new Function1<Link, Boolean>() {
+      @Override
+      public Boolean apply(final Link it) {
+        TransitionBase _transition = it.getTransition();
+        return Boolean.valueOf(TestStatesTriggers.this.roomNameProvider.getFullPath(((Transition) _transition)).equals("State3_TRANS_tr1_FROM_tp1_TO_State3"));
+      }
+    };
+    final Link tr = IteratorExtensions.<Link>head(IteratorExtensions.<Link>filter(FsmGenExtensions.getAllLinks(this.gc.getGraph()), _function));
+    Assert.assertNotNull("transition found", tr);
+    Assert.assertEquals("one chain head", 1, tr.getChainHeads().size());
+    TransitionBase _transition = IterableExtensions.<Link>head(tr.getChainHeads()).getTransition();
+    Assert.assertEquals("correct chain head", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", this.roomNameProvider.getFullPath(((Transition) _transition)));
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.java b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.java
new file mode 100644
index 000000000..222a967be
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.genmodel.fsm.tests/xtend-gen/org/eclipse/etrice/core/genmodel/fsm/tests/TestTrigger.java
@@ -0,0 +1,135 @@
+/**
+ * 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.tests;
+
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenExtensions;
+import org.eclipse.etrice.core.genmodel.fsm.NullLogger;
+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.Node;
+import org.eclipse.etrice.core.genmodel.fsm.tests.FsmGenTestBase;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestTrigger extends FsmGenTestBase {
+  private GraphContainer gc;
+  
+  @Before
+  public void SetUp() {
+    this.gc = this.getGraphContainer("TriggerExample.room", "TestActor");
+    Assert.assertNotNull("graph context was created", this.gc);
+    final NullLogger logger = new NullLogger();
+    FsmGenChecker.check(this.gc, logger);
+    Assert.assertFalse("logger has no errors", logger.hasErrors());
+    this.builder.withTriggersInStates(this.gc);
+    Assert.assertFalse("diagnostician has no errors", this.diagnostician.isFailed());
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state0_0"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertEquals("leave state triggers", 3, s.getCaughtTriggers().size());
+  }
+  
+  @Test
+  public void testNoTrigger() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state0"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("non-leave state has no caught triggers", 0, s.getCaughtTriggers().size());
+  }
+  
+  @Test
+  public void testTrigger_state0_0() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state0_0"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("leave state triggers", 3, s.getCaughtTriggers().size());
+    Assert.assertEquals("1st trigger", this.trigger("in3"), s.getCaughtTriggers().get(0).getTrigger());
+    Assert.assertEquals("1st trigger, transitions", 1, s.getCaughtTriggers().get(0).getLinks().size());
+    Assert.assertEquals("2nd trigger", this.trigger("in1"), s.getCaughtTriggers().get(1).getTrigger());
+    Assert.assertEquals("2nd trigger, transitions", 1, s.getCaughtTriggers().get(1).getLinks().size());
+    Assert.assertEquals("3rd trigger", this.trigger("in2"), s.getCaughtTriggers().get(2).getTrigger());
+    Assert.assertEquals("3rd trigger, transitions", 1, s.getCaughtTriggers().get(2).getLinks().size());
+  }
+  
+  @Test
+  public void testTrigger_state0_1() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state0_1"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("leave state triggers", 2, s.getCaughtTriggers().size());
+    Assert.assertEquals("1st trigger", this.trigger("in2"), s.getCaughtTriggers().get(0).getTrigger());
+    Assert.assertEquals("1st trigger, transitions", 1, s.getCaughtTriggers().get(0).getLinks().size());
+    Assert.assertEquals("2nd trigger", this.trigger("in1"), s.getCaughtTriggers().get(1).getTrigger());
+    Assert.assertEquals("2nd trigger, transitions", 1, s.getCaughtTriggers().get(1).getLinks().size());
+  }
+  
+  @Test
+  public void testTrigger_state1_0() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1_0"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("leave state triggers", 2, s.getCaughtTriggers().size());
+    Assert.assertEquals("1st trigger", this.trigger("in1"), s.getCaughtTriggers().get(0).getTrigger());
+    Assert.assertEquals("1st trigger, transitions", 1, s.getCaughtTriggers().get(0).getLinks().size());
+    Assert.assertEquals("2nd trigger", this.trigger("in2"), s.getCaughtTriggers().get(1).getTrigger());
+    Assert.assertEquals("2nd trigger, transitions", 1, s.getCaughtTriggers().get(1).getLinks().size());
+  }
+  
+  @Test
+  public void testTrigger_state1_1() {
+    final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() {
+      @Override
+      public Boolean apply(final Node it) {
+        return Boolean.valueOf(FsmGenExtensions.getName(it).equals("state1_1"));
+      }
+    };
+    final Node s = IteratorExtensions.<Node>head(IteratorExtensions.<Node>filter(FsmGenExtensions.getAllStateNodes(this.gc.getGraph()), _function));
+    Assert.assertNotNull("state found", s);
+    Assert.assertEquals("leave state triggers", 2, s.getCaughtTriggers().size());
+    Assert.assertEquals("1st trigger", this.trigger("in1"), s.getCaughtTriggers().get(0).getTrigger());
+    Assert.assertEquals("1st trigger, transitions", 3, s.getCaughtTriggers().get(0).getLinks().size());
+    Assert.assertEquals("2nd trigger", this.trigger("in2"), s.getCaughtTriggers().get(1).getTrigger());
+    Assert.assertEquals("2nd trigger, transitions", 1, s.getCaughtTriggers().get(1).getLinks().size());
+  }
+  
+  public String trigger(final String msg) {
+    return (("p0" + TriggerExtensions.TRIGGER_SEP) + msg);
+  }
+}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/models/states.room b/tests/org.eclipse.etrice.core.genmodel.tests/models/states.room
deleted file mode 100644
index 22ba965f2..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/models/states.room
+++ /dev/null
@@ -1,108 +0,0 @@
-RoomModel states {
-
-	PrimitiveType int32: ptInteger -> int32 (Integer) default "0"
-
-	ProtocolClass PTest1 {
-		incoming {
-			Message a ()
-			Message b (x : int32)
-			Message c ()
-		}
-		outgoing {
-			Message x ()
-		}
-	}
-
-	SubSystemClass CMain {
-		ActorRef test : ATest
-	}
-
-	ActorClass ATest {
-		Interface {
-			Port fct : PTest1
-		}
-		Structure {
-			external Port fct
-		}
-		Behavior {
-			StateMachine {
-				State State1 {}
-				State State2 {}
-				State State3 {
-				subgraph {
-						State State1 {}
-						State State2 {}
-						State State3 {}
-						EntryPoint tp1
-						TransitionPoint tp2
-						ExitPoint tp3
-						Transition tr0: initial -> State1 {}
-						Transition tr1: my tp1 -> State3 {}
-						Transition tr2: State1 -> State2 {
-							triggers {
-								<b:fct>
-							}
-						}
-						Transition tr3: State2 -> State3 {
-							triggers {
-								<c:fct>
-							}
-						}
-						Transition tr4: State3 -> State1 {
-							triggers {
-								<a:fct>
-							}
-						}
-						Transition tr5: my tp2 -> State3 {
-							triggers {
-								<b:fct>
-							}
-						}
-						Transition tr6: State3 -> my tp3 {
-							triggers {
-								<c:fct>
-							}
-						}
-					}
-				}
-				State State4 {}
-				TransitionPoint tp0
-				ChoicePoint CP1
-				Transition tr0: initial -> State1 {}
-				Transition tr1: State1 -> State2 {
-					triggers {
-						<a:fct>
-					}
-				}
-				Transition tr2: State2 -> cp CP1 {
-					triggers {
-						<b:fct>
-					}
-				}
-				Transition tr3: cp CP1 -> State1 {}
-				Transition tr4: cp CP1 -> State3 {
-					cond {
-						"x==2"
-					}
-				}
-				Transition tr5: my tp0 -> tp1 of State3 {
-					triggers {
-						<a:fct>
-					}
-				}
-				Transition tr6: cp CP1 -> State4 {
-					cond {
-						"x==3"
-					}
-				}
-				Transition tr7: tp3 of State3 -> State2 {}
-				Transition tr8: State3 -> State2 {
-					triggers {
-						<c:fct>
-					}
-				}
-			}
-		}
-	}
-
-}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/org.eclipse.etrice.core.genmodel.tests.launch b/tests/org.eclipse.etrice.core.genmodel.tests/org.eclipse.etrice.core.genmodel.tests.launch
index c16a57ec4..06c1560bc 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/org.eclipse.etrice.core.genmodel.tests.launch
+++ b/tests/org.eclipse.etrice.core.genmodel.tests/org.eclipse.etrice.core.genmodel.tests.launch
@@ -11,7 +11,7 @@
 <booleanAttribute key="clearws" value="true"/>
 <booleanAttribute key="clearwslog" value="false"/>
 <stringAttribute key="configLocation" value="${workspace_loc}/.metadata/.plugins/org.eclipse.pde.core/pde-junit"/>
-<booleanAttribute key="default" value="false"/>
+<booleanAttribute key="default" value="true"/>
 <booleanAttribute key="includeOptional" value="false"/>
 <stringAttribute key="location" value="${workspace_loc}/../junit-workspace"/>
 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
@@ -33,8 +33,8 @@
 <stringAttribute key="pde.version" value="3.3"/>
 <stringAttribute key="product" value="org.eclipse.sdk.ide"/>
 <booleanAttribute key="run_in_ui_thread" value="false"/>
-<stringAttribute key="selected_target_plugins" value="com.google.guava@default:default,com.google.inject@default:default,javax.inject@default:default,javax.xml@default:default,org.antlr.runtime@default:default,org.apache.log4j@default:default,org.eclipse.core.contenttype@default:default,org.eclipse.core.expressions@default:default,org.eclipse.core.filesystem.win32.x86_64@default:false,org.eclipse.core.filesystem@default:default,org.eclipse.core.jobs@default:default,org.eclipse.core.resources.win32.x86_64@default:false,org.eclipse.core.resources@default:default,org.eclipse.core.runtime@default:true,org.eclipse.emf.common@default:default,org.eclipse.emf.ecore.xmi@default:default,org.eclipse.emf.ecore@default:default,org.eclipse.equinox.app@default:default,org.eclipse.equinox.common@2:true,org.eclipse.equinox.preferences@default:default,org.eclipse.equinox.registry@default:default,org.eclipse.osgi.compatibility.state@default:false,org.eclipse.osgi@-1:true,org.eclipse.pde.junit.runtime@default:default,org.eclipse.xtend.lib.macro@default:default,org.eclipse.xtend.lib@default:default,org.eclipse.xtext.common.types@default:default,org.eclipse.xtext.logging@default:false,org.eclipse.xtext.smap@default:default,org.eclipse.xtext.util@default:default,org.eclipse.xtext.xbase.lib@default:default,org.eclipse.xtext@default:default,org.hamcrest.core@default:default,org.junit@default:default,org.objectweb.asm@default:default"/>
-<stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.genmodel.fsm@default:default,org.eclipse.etrice.core.genmodel.tests@default:default,org.eclipse.etrice.core.genmodel@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.logging@default:false"/>
+<stringAttribute key="selected_target_plugins" value="com.google.guava@default:default,com.google.inject@default:default,com.ibm.icu@default:default,javax.inject@default:default,javax.xml@default:default,org.antlr.runtime@default:default,org.apache.batik.css@default:default,org.apache.batik.util.gui@default:default,org.apache.batik.util@default:default,org.apache.commons.jxpath@default:default,org.apache.log4j@default:default,org.eclipse.ant.core@default:default,org.eclipse.compare.core@default:default,org.eclipse.core.commands@default:default,org.eclipse.core.contenttype@default:default,org.eclipse.core.databinding.observable@default:default,org.eclipse.core.databinding.property@default:default,org.eclipse.core.databinding@default:default,org.eclipse.core.expressions@default:default,org.eclipse.core.filesystem.win32.x86_64@default:false,org.eclipse.core.filesystem@default:default,org.eclipse.core.jobs@default:default,org.eclipse.core.resources.win32.x86_64@default:false,org.eclipse.core.resources@default:default,org.eclipse.core.runtime@default:true,org.eclipse.core.variables@default:default,org.eclipse.e4.core.commands@default:default,org.eclipse.e4.core.contexts@default:default,org.eclipse.e4.core.di.annotations@default:default,org.eclipse.e4.core.di.extensions@default:default,org.eclipse.e4.core.di@default:default,org.eclipse.e4.core.services@default:default,org.eclipse.e4.emf.xpath@default:default,org.eclipse.e4.ui.bindings@default:default,org.eclipse.e4.ui.css.core@default:default,org.eclipse.e4.ui.css.swt.theme@default:default,org.eclipse.e4.ui.css.swt@default:default,org.eclipse.e4.ui.di@default:default,org.eclipse.e4.ui.model.workbench@default:default,org.eclipse.e4.ui.services@default:default,org.eclipse.e4.ui.widgets@default:default,org.eclipse.e4.ui.workbench.addons.swt@default:default,org.eclipse.e4.ui.workbench.renderers.swt@default:default,org.eclipse.e4.ui.workbench.swt@default:default,org.eclipse.e4.ui.workbench3@default:default,org.eclipse.e4.ui.workbench@default:default,org.eclipse.emf.common@default:default,org.eclipse.emf.ecore.change@default:default,org.eclipse.emf.ecore.xmi@default:default,org.eclipse.emf.ecore@default:default,org.eclipse.equinox.app@default:default,org.eclipse.equinox.common@2:true,org.eclipse.equinox.preferences@default:default,org.eclipse.equinox.registry@default:default,org.eclipse.fx.osgi@default:false,org.eclipse.help@default:default,org.eclipse.jdt.junit.runtime@default:default,org.eclipse.jface.databinding@default:default,org.eclipse.jface@default:default,org.eclipse.osgi.compatibility.state@default:false,org.eclipse.osgi.services@default:default,org.eclipse.osgi@-1:true,org.eclipse.pde.junit.runtime@default:default,org.eclipse.swt.win32.win32.x86_64@default:false,org.eclipse.swt@default:default,org.eclipse.team.core@default:default,org.eclipse.ui.trace@default:default,org.eclipse.ui.workbench@default:default,org.eclipse.ui@default:default,org.eclipse.xtend.lib.macro@default:default,org.eclipse.xtend.lib@default:default,org.eclipse.xtext.common.types@default:default,org.eclipse.xtext.logging@default:false,org.eclipse.xtext.smap@default:default,org.eclipse.xtext.util@default:default,org.eclipse.xtext.xbase.lib@default:default,org.eclipse.xtext@default:default,org.hamcrest.core@default:default,org.junit@default:default,org.objectweb.asm@default:default,org.w3c.css.sac@default:default,org.w3c.dom.events@default:default,org.w3c.dom.smil@default:default,org.w3c.dom.svg@default:default"/>
+<stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.genmodel.fsm2@default:default,org.eclipse.etrice.core.genmodel.fsm@default:default,org.eclipse.etrice.core.genmodel.tests@default:default,org.eclipse.etrice.core.genmodel@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.logging@default:false"/>
 <booleanAttribute key="show_selected_only" value="false"/>
 <booleanAttribute key="tracing" value="false"/>
 <booleanAttribute key="useCustomFeatures" value="false"/>
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestCodeInheritance.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestCodeInheritance.java
deleted file mode 100644
index d62d3eaa5..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestCodeInheritance.java
+++ /dev/null
@@ -1,125 +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.core.genmodel;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.util.FSMHelpers;
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.ExpandedRefinedState;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FsmGenPackage;
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class TestCodeInheritance extends TestInstanceModelBuilderBase {
-	
-	private Root root;
-	private HashMap<EClass, ArrayList<EObject>> baseInstances;
-	private HashMap<EClass, ArrayList<EObject>> derivedInstances;
-	private ExpandedActorClass base;
-	private ExpandedActorClass derived;
-	private FSMHelpers fsmHelpers = new FSMHelpers();
-	
-	@Before
-	public void setUp() {
-		prepare();
-		
-		root = buildInstanceModel("code_inheritance.room");
-		base = getActor("Base");
-		derived = getActor("Deriv");
-		baseInstances = collectInstances(base);
-		derivedInstances = collectInstances(derived);
-	}
-
-	private ExpandedActorClass getActor(String name) {
-		for (ExpandedActorClass xpac : root.getXpActorClasses()) {
-			if (xpac.getActorClass().getName().equals(name))
-				return xpac;
-		}
-		return null;
-	}
-	
-	private State getState(ExpandedActorClass xpac, String name) {
-		for (State s : xpac.getStateMachine().getStates()) {
-			if (s.getName().equals(name))
-				return s;
-		}
-		return null;
-	}
-	
-	@Test
-	public void testNumbers() {
-		assertEquals("number of states", 6, baseInstances.get(FSMPackage.eINSTANCE.getSimpleState()).size());
-		assertNull("number of choice points", baseInstances.get(FSMPackage.eINSTANCE.getChoicePoint()));
-		assertNull("number of transition points", baseInstances.get(FSMPackage.eINSTANCE.getTransitionPoint()));
-		assertNull("number of entry points", baseInstances.get(FSMPackage.eINSTANCE.getEntryPoint()));
-		assertNull("number of exit points", baseInstances.get(FSMPackage.eINSTANCE.getExitPoint()));
-		assertEquals("number of initial transitions", 3, baseInstances.get(FSMPackage.eINSTANCE.getInitialTransition()).size());
-		assertEquals("number of triggered transitions", 3, baseInstances.get(FSMPackage.eINSTANCE.getTriggeredTransition()).size());
-		assertNull("number of continuation transitions", baseInstances.get(FSMPackage.eINSTANCE.getContinuationTransition()));
-		assertNull("number of branch transitions", baseInstances.get(FSMPackage.eINSTANCE.getCPBranchTransition()));
-
-		assertEquals("number of states", 4, derivedInstances.get(FSMPackage.eINSTANCE.getSimpleState()).size());
-		assertEquals("number of states", 3, derivedInstances.get(FsmGenPackage.eINSTANCE.getExpandedRefinedState()).size());
-		assertNull("number of choice points", derivedInstances.get(FSMPackage.eINSTANCE.getChoicePoint()));
-		assertNull("number of transition points", derivedInstances.get(FSMPackage.eINSTANCE.getTransitionPoint()));
-		assertNull("number of entry points", derivedInstances.get(FSMPackage.eINSTANCE.getEntryPoint()));
-		assertNull("number of exit points", derivedInstances.get(FSMPackage.eINSTANCE.getExitPoint()));
-		assertEquals("number of initial transitions", 4, derivedInstances.get(FSMPackage.eINSTANCE.getInitialTransition()).size());
-		assertEquals("number of triggered transitions", 3, derivedInstances.get(FSMPackage.eINSTANCE.getTriggeredTransition()).size());
-		assertNull("number of continuation transitions", derivedInstances.get(FSMPackage.eINSTANCE.getContinuationTransition()));
-		assertNull("number of branch transitions", derivedInstances.get(FSMPackage.eINSTANCE.getCPBranchTransition()));
-	}
-	
-	@Test
-	public void testActionCodes() {
-		State s = getState(derived, "BaseEntryExit");
-		assertTrue("is ExpandedRefinedState", s instanceof ExpandedRefinedState);
-		ExpandedRefinedState rs = (ExpandedRefinedState) s;
-		assertEquals("entry code", "// derived entry\n", fsmHelpers.getDetailCode(rs.getEntryCode()));
-		assertNull("exit code", rs.getExitCode());
-		assertEquals("inherited entry", "// base entry\n", fsmHelpers.getDetailCode(rs.getInheritedEntry()));
-		assertEquals("inherited exit", "// base exit\n", fsmHelpers.getDetailCode(rs.getInheritedExit()));
-		
-		s = getState(derived, "Base");
-		assertTrue("is ExpandedRefinedState", s instanceof ExpandedRefinedState);
-		rs = (ExpandedRefinedState) s;
-		assertNull("entry code", rs.getEntryCode());
-		assertEquals("exit code", "// derived exit\n", fsmHelpers.getDetailCode(rs.getExitCode()));
-		assertEquals("inherited entry", "", fsmHelpers.getDetailCode(rs.getInheritedEntry()));
-		assertEquals("inherited exit", "", fsmHelpers.getDetailCode(rs.getInheritedExit()));
-		
-		s = getState(derived, "BaseSub");
-		assertTrue("is ExpandedRefinedState", s instanceof ExpandedRefinedState);
-		rs = (ExpandedRefinedState) s;
-		assertEquals("entry code", "// derived entry\n", fsmHelpers.getDetailCode(rs.getEntryCode()));
-		assertNull("exit code", rs.getExitCode());
-		assertEquals("inherited entry", "", fsmHelpers.getDetailCode(rs.getInheritedEntry()));
-		assertEquals("inherited exit", "", fsmHelpers.getDetailCode(rs.getInheritedExit()));
-	}
-
-}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestInstanceModelBuilderBase.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestInstanceModelBuilderBase.java
index 9b8643f70..dd88aaab5 100644
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestInstanceModelBuilderBase.java
+++ b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestInstanceModelBuilderBase.java
@@ -29,30 +29,18 @@ import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
+import org.eclipse.etrice.core.genmodel.builder.GeneratorModelBuilder;
 import org.eclipse.etrice.core.genmodel.etricegen.InstanceBase;
 import org.eclipse.etrice.core.genmodel.etricegen.Root;
-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.NullLogger;
 import org.eclipse.etrice.core.naming.RoomNameProvider;
+import org.eclipse.etrice.core.room.RoomModel;
 import org.eclipse.xtext.resource.XtextResource;
 import org.eclipse.xtext.resource.XtextResourceSet;
-import org.eclipse.etrice.core.room.RoomModel;
-import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
-import org.eclipse.etrice.core.genmodel.builder.GeneratorModelBuilder;
 
 public class TestInstanceModelBuilderBase {
-
-	class Logger implements ILogger {
-
-		@Override
-		public void logInfo(String text) {
-		}
-
-		@Override
-		public void logError(String text, EObject obj) {
-		}
-		
-	}
 	
 	class Diagnostician implements IDiagnostician {
 
@@ -112,7 +100,7 @@ public class TestInstanceModelBuilderBase {
 	}
 
 	protected Root buildInstanceModel(String modelName) {
-		GeneratorModelBuilder builder = new GeneratorModelBuilder(new Logger(), new Diagnostician());
+		GeneratorModelBuilder builder = new GeneratorModelBuilder(new NullLogger(), new Diagnostician());
 		LinkedList<RoomModel> models = getModels(modelName);
 		ArrayList<RoomModel> importedModels = new ArrayList<>();
 		Root root = builder.createGeneratorModel(models, importedModels, false);
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestMultipleConnectedChoicepoint.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestMultipleConnectedChoicepoint.java
deleted file mode 100644
index 49b4fc59b..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestMultipleConnectedChoicepoint.java
+++ /dev/null
@@ -1,155 +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.core.genmodel;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-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.FSMPackage;
-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.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.naming.RoomNameProvider;
-import org.eclipse.etrice.core.room.DataClass;
-import org.eclipse.etrice.core.room.VarDecl;
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author Henrik Rentz-Reichert
- *
- */
-public class TestMultipleConnectedChoicepoint extends
-		TestInstanceModelBuilderBase {
-	
-	private Root root;
-	private ExpandedActorClass xpac;
-	private RoomNameProvider roomNameProvider = new RoomNameProvider();
-	
-	@Before
-	public void setUp() {
-		prepare();
-		
-		root = buildInstanceModel("cpmult.room");
-		xpac = getTestee();
-		instances = collectInstances(xpac);
-	}
-
-	private ExpandedActorClass getTestee() {
-		for (ExpandedActorClass xpac : root.getXpActorClasses()) {
-			if (xpac.getActorClass().getName().equals("CPMult"))
-				return xpac;
-		}
-		return null;
-	}
-	
-	private Transition getTransition(String name) {
-		for (Transition tr : xpac.getStateMachine().getTransitions()) {
-			if (tr.getName().equals(name))
-				return tr;
-		}
-		return null;
-	}
-	
-	private Transition getState1Transition(String name) {
-		for (State s : xpac.getStateMachine().getStates()) {
-			if (s.getName().equals("state1")) {
-				for (Transition tr : s.getSubgraph().getTransitions()) {
-					if (tr.getName().equals(name))
-						return tr;
-				}
-			}
-		}
-		return null;
-	}
-	
-	@Test
-	public void testNumbers() {
-		assertEquals("number of states", 6, instances.get(FSMPackage.eINSTANCE.getSimpleState()).size());
-		assertEquals("number of choice points", 1, instances.get(FSMPackage.eINSTANCE.getChoicePoint()).size());
-		assertNull("number of transition points", instances.get(FSMPackage.eINSTANCE.getTransitionPoint()));
-		assertEquals("number of entry points", 1, instances.get(FSMPackage.eINSTANCE.getEntryPoint()).size());
-		assertEquals("number of exit points", 1, instances.get(FSMPackage.eINSTANCE.getExitPoint()).size());
-		assertEquals("number of initial transitions", 1, instances.get(FSMPackage.eINSTANCE.getInitialTransition()).size());
-		assertEquals("number of triggered transitions", 5, instances.get(FSMPackage.eINSTANCE.getTriggeredTransition()).size());
-		assertEquals("number of continuation transitions", 3, instances.get(FSMPackage.eINSTANCE.getContinuationTransition()).size());
-		assertEquals("number of branch transitions", 1, instances.get(FSMPackage.eINSTANCE.getCPBranchTransition()).size());
-	}
-	
-	@Test
-	public void testXPACGeneral() {
-		EList<TransitionChain> chains = xpac.getTransitionChains();
-		assertEquals("number of chains", 6, chains.size());
-		assertEquals("number of triggers", 4, xpac.getTriggers().size());
-	}
-	
-	@Test
-	public void testGraph() {
-		ArrayList<EObject> cps = instances.get(FSMPackage.eINSTANCE.getChoicePoint());
-		ChoicePoint cp = (ChoicePoint) cps.get(0);
-		assertEquals("choicepoint name", "cp0", roomNameProvider.getFullPath(cp));
-		assertEquals("number of incoming transitions", 2, xpac.getIncomingTransitions(cp).size());
-		assertEquals("number of outgoing transitions", 2, xpac.getOutgoingTransitions(cp).size());
-	}
-	
-	@Test
-	public void testData() {
-		Transition tr = getTransition("tr0");
-		VarDecl data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is TriggeredTransition", tr instanceof TriggeredTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC2", data.getRefType().getType().getName());
-		
-		tr = getState1Transition("tr2");
-		data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is TriggeredTransition", tr instanceof TriggeredTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC2", data.getRefType().getType().getName());
-		
-		tr = getState1Transition("tr3");
-		data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is TriggeredTransition", tr instanceof TriggeredTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC4", data.getRefType().getType().getName());
-		
-		tr = getTransition("tr1");
-		data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is TriggeredTransition", tr instanceof TriggeredTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC3", data.getRefType().getType().getName());
-		
-		tr = getTransition("tr3");
-		data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is ContinuationTransition", tr instanceof ContinuationTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC", data.getRefType().getType().getName());
-		
-		tr = getTransition("tr4");
-		data = (VarDecl) xpac.getData(tr);
-		assertTrue("transition is CPBranchTransition", tr instanceof CPBranchTransition);
-		assertTrue("data is DataClass", data.getRefType().getType() instanceof DataClass);
-		assertEquals("data of "+tr.getName(), "DC", data.getRefType().getType().getName());
-	}
-
-}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStates.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStates.java
deleted file mode 100644
index 87ca6e00f..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStates.java
+++ /dev/null
@@ -1,117 +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;
-
-import static org.junit.Assert.*;
-
-import java.util.ArrayList;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.naming.RoomNameProvider;
-import org.junit.Before;
-import org.junit.Test;
-import org.eclipse.etrice.core.fsm.fSM.ChoicePoint;
-import org.eclipse.etrice.core.fsm.fSM.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-
-public class TestStates extends TestInstanceModelBuilderBase {
-	
-	private Root root;
-	private RoomNameProvider roomNameProvider = new RoomNameProvider();
-	
-	@Before
-	public void setUp() {
-		prepare();
-		
-		root = buildInstanceModel("states.room");
-		instances = collectInstances(root.getXpActorClasses().get(0));
-	}
-	
-	@Test
-	public void testNumbers() {
-		checkSize(7, FSMPackage.eINSTANCE.getSimpleState());
-		checkSize(1, FSMPackage.eINSTANCE.getChoicePoint());
-		checkSize(2, FSMPackage.eINSTANCE.getTransitionPoint());
-		checkSize(1, FSMPackage.eINSTANCE.getEntryPoint());
-		checkSize(1, FSMPackage.eINSTANCE.getExitPoint());
-		checkSize(2, FSMPackage.eINSTANCE.getInitialTransition());
-		checkSize(9, FSMPackage.eINSTANCE.getTriggeredTransition());
-		checkSize(3, FSMPackage.eINSTANCE.getContinuationTransition());
-		checkSize(2, FSMPackage.eINSTANCE.getCPBranchTransition());
-	}
-	
-	@Test
-	public void testXPACGeneral() {
-		ExpandedActorClass xpac = root.getXpActorClasses().get(0);
-		assertEquals("actor class", xpac.getActorClass().getName(), "ATest");
-		EList<TransitionChain> chains = xpac.getTransitionChains();
-		assertEquals("number of chains", 11, chains.size());
-		assertEquals("numer of triggers", 3, xpac.getTriggers().size());
-	}
-	
-	@Test
-	public void testGraph() {
-		ArrayList<EObject> states = instances.get(FSMPackage.eINSTANCE.getSimpleState());
-//		for (EObject obj : states) {
-//			LogicalSystem.out.println("state "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-
-		ExpandedActorClass xpac = root.getXpActorClasses().get(0);
-		
-		State s = (State) getStateGraphItem(states, "State3_State3");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 3, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 2, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 3, xpac.getActiveTriggers(s).size());
-		
-		s = (State) getStateGraphItem(states, "State2");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 3, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 1, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 2, xpac.getActiveTriggers(s).size());
-
-		ArrayList<EObject> cps = instances.get(FSMPackage.eINSTANCE.getChoicePoint());
-		
-		ChoicePoint cp = (ChoicePoint) cps.get(0);
-		assertEquals("choicepoint name", "CP1", roomNameProvider.getFullPath(cp));
-		assertEquals("number of incoming transitions", 1, xpac.getIncomingTransitions(cp).size());
-		assertEquals("number of outgoing transitions", 3, xpac.getOutgoingTransitions(cp).size());
-		
-		ContinuationTransition dflt = xpac.getDefaultBranch(xpac.getOutgoingTransitions(cp));
-		assertNotNull("default branch", dflt);
-	}
-	
-	@Test
-	public void testChains() {
-		ArrayList<EObject> cts = instances.get(FSMPackage.eINSTANCE.getContinuationTransition());
-//		for (EObject obj : cts) {
-//			LogicalSystem.out.println("ct "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-		
-		Transition t = (Transition) getStateGraphItem(cts, "State3_TRANS_tr1_FROM_tp1_TO_State3");
-		assertNotNull("transition", t);
-
-		ExpandedActorClass xpac = root.getXpActorClasses().get(0);
-		TransitionChain chain = xpac.getChain(t);
-		assertNotNull("chain", chain);
-		assertEquals("chain name", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", roomNameProvider.getFullPath(chain.getTransition()));
-	}
-}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesAndTriggers.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesAndTriggers.java
deleted file mode 100644
index 942986758..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesAndTriggers.java
+++ /dev/null
@@ -1,142 +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;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.ArrayList;
-
-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.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.naming.RoomNameProvider;
-import org.eclipse.etrice.core.room.Port;
-import org.eclipse.etrice.core.room.SAP;
-import org.junit.Before;
-import org.junit.Test;
-
-public class TestStatesAndTriggers extends TestInstanceModelBuilderBase {
-	
-	private Root root;
-	private ExpandedActorClass xpac;
-	private RoomNameProvider roomNameProvider = new RoomNameProvider();
-	
-	@Before
-	public void setUp() {
-		prepare();
-		
-		root = buildInstanceModel("states_triggers.room");
-		xpac = getTestee();
-		instances = collectInstances(xpac);
-	}
-
-	private ExpandedActorClass getTestee() {
-		for (ExpandedActorClass xpac : root.getXpActorClasses()) {
-			if (xpac.getActorClass().getName().equals("ATest"))
-				return xpac;
-		}
-		return null;
-	}
-	
-	@Test
-	public void testNumbers() {
-		checkSize(7, FSMPackage.eINSTANCE.getSimpleState());
-		checkSize(1, FSMPackage.eINSTANCE.getChoicePoint());
-		checkSize(4, FSMPackage.eINSTANCE.getTransitionPoint());
-		checkSize(1, FSMPackage.eINSTANCE.getEntryPoint());
-		checkSize(1, FSMPackage.eINSTANCE.getExitPoint());
-		checkSize(2, FSMPackage.eINSTANCE.getInitialTransition());
-		checkSize(11, FSMPackage.eINSTANCE.getTriggeredTransition());
-		checkSize(3, FSMPackage.eINSTANCE.getContinuationTransition());
-		checkSize(2, FSMPackage.eINSTANCE.getCPBranchTransition());
-	}
-	
-	@Test
-	public void testXPACGeneral() {
-		EList<TransitionChain> chains = xpac.getTransitionChains();
-		assertEquals("number of chains", 13, chains.size());
-		assertEquals("numer of triggers", 7, xpac.getTriggers().size());
-	}
-	
-	@Test
-	public void testGraph() {
-		ArrayList<EObject> states = instances.get(FSMPackage.eINSTANCE.getSimpleState());
-//		for (EObject obj : states) {
-//			LogicalSystem.out.println("state "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-
-		State s = (State) getStateGraphItem(states, "State3_State3");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 3, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 2, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 6, xpac.getActiveTriggers(s).size());
-		
-		s = (State) getStateGraphItem(states, "State2");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 4, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 1, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 3, xpac.getActiveTriggers(s).size());
-
-		ArrayList<EObject> cps = instances.get(FSMPackage.eINSTANCE.getChoicePoint());
-		
-		ChoicePoint cp = (ChoicePoint) cps.get(0);
-		assertEquals("choicepoint name", "CP1", roomNameProvider.getFullPath(cp));
-		assertEquals("number of incoming transitions", 1, xpac.getIncomingTransitions(cp).size());
-		assertEquals("number of outgoing transitions", 3, xpac.getOutgoingTransitions(cp).size());
-		
-		ContinuationTransition dflt = xpac.getDefaultBranch(xpac.getOutgoingTransitions(cp));
-		assertNotNull("default branch", dflt);
-	}
-	
-	@Test
-	public void testChains() {
-		ArrayList<EObject> cts = instances.get(FSMPackage.eINSTANCE.getContinuationTransition());
-//		for (EObject obj : cts) {
-//			LogicalSystem.out.println("ct "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-		
-		Transition t = (Transition) getStateGraphItem(cts, "State3_TRANS_tr1_FROM_tp1_TO_State3");
-		assertNotNull("transition", t);
-
-		TransitionChain chain = xpac.getChain(t);
-		assertNotNull("chain", chain);
-		assertEquals("chain name", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", roomNameProvider.getFullPath(chain.getTransition()));
-	}
-	
-	@Test
-	public void testIfItems() {
-		Port fct = xpac.getActorClass().getInterfacePorts().get(0);
-		Port sub = xpac.getActorClass().getInternalPorts().get(0);
-		SAP timer = xpac.getActorClass().getServiceAccessPoints().get(0);
-		SAP timeout = xpac.getActorClass().getServiceAccessPoints().get(1);
-		
-		assertEquals("port name", "fct", fct.getName());
-		assertEquals("port name", "subp", sub.getName());
-		assertEquals("sap name", "timer", timer.getName());
-		assertEquals("sap name", "timeout", timeout.getName());
-		
-		assertEquals("port local id", 0, xpac.getInterfaceItemLocalId(sub));
-		assertEquals("port local id", 1, xpac.getInterfaceItemLocalId(fct));
-		assertEquals("sap local id", 2, xpac.getInterfaceItemLocalId(timer));
-		assertEquals("sap local id", 3, xpac.getInterfaceItemLocalId(timeout));
-	}
-}
diff --git a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesInheritance.java b/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesInheritance.java
deleted file mode 100644
index 7aa0d9230..000000000
--- a/tests/org.eclipse.etrice.core.genmodel.tests/src/org/eclipse/etrice/core/genmodel/TestStatesInheritance.java
+++ /dev/null
@@ -1,142 +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;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.ArrayList;
-
-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.ContinuationTransition;
-import org.eclipse.etrice.core.fsm.fSM.FSMPackage;
-import org.eclipse.etrice.core.fsm.fSM.State;
-import org.eclipse.etrice.core.fsm.fSM.Transition;
-import org.eclipse.etrice.core.genmodel.etricegen.ExpandedActorClass;
-import org.eclipse.etrice.core.genmodel.etricegen.Root;
-import org.eclipse.etrice.core.genmodel.fsm.fsmgen.TransitionChain;
-import org.eclipse.etrice.core.naming.RoomNameProvider;
-import org.junit.Before;
-import org.junit.Test;
-
-public class TestStatesInheritance extends TestInstanceModelBuilderBase {
-	
-	private Root root;
-	private ExpandedActorClass xpac;
-	private RoomNameProvider roomNameProvider = new RoomNameProvider();
-	
-	@Before
-	public void setUp() {
-		prepare();
-		
-		root = buildInstanceModel("states_inheritance.room");
-		xpac = getTestee();
-		instances = collectInstances(xpac);
-	}
-
-	private ExpandedActorClass getTestee() {
-		for (ExpandedActorClass xpac : root.getXpActorClasses()) {
-			if (xpac.getActorClass().getName().equals("ADerived"))
-				return xpac;
-		}
-		return null;
-	}
-
-//	private void assertEquals(String msg, int exp, int is) {
-//		LogicalSystem.out.println(msg+" exp:"+exp+" is:"+is);
-//	}
-//
-//	private void assertEquals(String msg, String exp, String is) {
-//		LogicalSystem.out.println(msg+" exp:"+exp+" is:"+is);
-//	}
-//
-//	private void assertEquals(String msg, EObject exp, EObject is) {
-//		LogicalSystem.out.println(msg+" exp:"+exp+" is:"+is);
-//	}
-	
-	@Test
-	public void testNumbers() {
-		checkSize(9, FSMPackage.eINSTANCE.getSimpleState());
-		checkSize(1, FSMPackage.eINSTANCE.getChoicePoint());
-		checkSize(5, FSMPackage.eINSTANCE.getTransitionPoint());
-		checkSize(2, FSMPackage.eINSTANCE.getEntryPoint());
-		checkSize(1, FSMPackage.eINSTANCE.getExitPoint());
-		checkSize(3, FSMPackage.eINSTANCE.getInitialTransition());
-		checkSize(17, FSMPackage.eINSTANCE.getTriggeredTransition());
-		checkSize(4, FSMPackage.eINSTANCE.getContinuationTransition());
-		checkSize(3, FSMPackage.eINSTANCE.getCPBranchTransition());
-	}
-	
-	@Test
-	public void testXPACGeneral() {
-		EList<TransitionChain> chains = xpac.getTransitionChains();
-		assertEquals("number of chains", 20, chains.size());
-		assertEquals("numer of triggers", 8, xpac.getTriggers().size());
-	}
-	
-	@Test
-	public void testGraph() {
-		ArrayList<EObject> states = instances.get(FSMPackage.eINSTANCE.getSimpleState());
-//		for (EObject obj : states) {
-//			LogicalSystem.out.println("state "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-
-		State s = (State) getStateGraphItem(states, "State3_State3");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 3, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 2, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 6, xpac.getActiveTriggers(s).size());
-		
-		s = (State) getStateGraphItem(states, "State2");
-		assertNotNull("state exists", s);
-		assertEquals("number of incoming transitions", 4, xpac.getIncomingTransitions(s).size());
-		assertEquals("number of outgoing transitions", 1, xpac.getOutgoingTransitions(s).size());
-		
-		assertEquals("active triggers", 3, xpac.getActiveTriggers(s).size());
-
-		ArrayList<EObject> cps = instances.get(FSMPackage.eINSTANCE.getChoicePoint());
-		
-		ChoicePoint cp = (ChoicePoint) cps.get(0);
-		assertEquals("choicepoint name", "CP1", roomNameProvider.getFullPath(cp));
-		assertEquals("number of incoming transitions", 1, xpac.getIncomingTransitions(cp).size());
-		assertEquals("number of outgoing transitions", 4, xpac.getOutgoingTransitions(cp).size());
-		
-		ContinuationTransition dflt = xpac.getDefaultBranch(xpac.getOutgoingTransitions(cp));
-		assertNotNull("default branch", dflt);
-	}
-	
-	@Test
-	public void testChains() {
-		ArrayList<EObject> cts = instances.get(FSMPackage.eINSTANCE.getContinuationTransition());
-//		for (EObject obj : cts) {
-//			LogicalSystem.out.println("ct "+RoomNameProvider.getFullPath((StateGraphItem) obj));
-//		}
-		
-		Transition t = (Transition) getStateGraphItem(cts, "State3_TRANS_tr1_FROM_tp1_TO_State3");
-		assertNotNull("transition", t);
-
-		TransitionChain chain = xpac.getChain(t);
-		assertNotNull("chain", chain);
-		assertEquals("chain name", "TRANS_tr5_FROM_tp0_TO_State3_tp1_BY_afct", roomNameProvider.getFullPath(chain.getTransition()));
-		
-		t = (Transition) getStateGraphItem(cts, "State3_TRANS_tr8_FROM_tp6_TO_State2");
-		assertNotNull("transition", t);
-
-		chain = xpac.getChain(t);
-		assertNotNull("chain", chain);
-		assertEquals("chain name", "TRANS_tr12_FROM_State5_TO_State3_tp6_BY_aport", roomNameProvider.getFullPath(chain.getTransition()));
-	}
-}
diff --git a/tests/org.eclipse.etrice.core.room.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.etrice.core.room.tests/META-INF/MANIFEST.MF
index c6acb3d89..249e68142 100644
--- a/tests/org.eclipse.etrice.core.room.tests/META-INF/MANIFEST.MF
+++ b/tests/org.eclipse.etrice.core.room.tests/META-INF/MANIFEST.MF
@@ -17,3 +17,4 @@ Require-Bundle: org.eclipse.etrice.core.room;bundle-version="1.1.1",
  org.eclipse.emf.ecore
 Bundle-Activator: org.eclipse.etrice.core.CoreTestsActivator
 Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.etrice.core
diff --git a/tests/org.eclipse.etrice.core.room.tests/org.eclipse.etrice.core.room.tests.launch b/tests/org.eclipse.etrice.core.room.tests/org.eclipse.etrice.core.room.tests.launch
index 6cb9c65b8..e7e2c69f0 100644
--- a/tests/org.eclipse.etrice.core.room.tests/org.eclipse.etrice.core.room.tests.launch
+++ b/tests/org.eclipse.etrice.core.room.tests/org.eclipse.etrice.core.room.tests.launch
@@ -36,9 +36,15 @@
 <stringAttribute key="pde.version" value="3.3"/>
 <stringAttribute key="product" value="org.eclipse.platform.ide"/>
 <booleanAttribute key="run_in_ui_thread" value="false"/>
+<<<<<<< Upstream, based on origin/master
 <stringAttribute key="selected_target_plugins" value="com.google.guava*15.0.0.v201403281430@default:default,com.google.guava*21.0.0.v20170206-1425@default:default,com.google.inject@default:default,javax.inject@default:default,javax.xml@default:default,org.antlr.runtime*3.2.0.v201101311130@default:default,org.antlr.runtime*4.3.0.v201502022030@default:default,org.apache.log4j@default:default,org.eclipse.core.contenttype@default:default,org.eclipse.core.expressions@default:default,org.eclipse.core.filesystem.win32.x86_64@default:false,org.eclipse.core.filesystem@default:default,org.eclipse.core.jobs@default:default,org.eclipse.core.resources.win32.x86_64@default:false,org.eclipse.core.resources@default:default,org.eclipse.core.runtime@default:true,org.eclipse.emf.common@default:default,org.eclipse.emf.ecore.xmi@default:default,org.eclipse.emf.ecore@default:default,org.eclipse.equinox.app@default:default,org.eclipse.equinox.common@2:true,org.eclipse.equinox.preferences@default:default,org.eclipse.equinox.registry@default:default,org.eclipse.osgi.compatibility.state@default:false,org.eclipse.osgi@-1:true,org.eclipse.xtend.core@default:default,org.eclipse.xtend.lib.macro@default:default,org.eclipse.xtend.lib@default:default,org.eclipse.xtext.common.types@default:default,org.eclipse.xtext.logging@default:false,org.eclipse.xtext.smap@default:default,org.eclipse.xtext.util@default:default,org.eclipse.xtext.xbase.lib@default:default,org.eclipse.xtext.xbase@default:default,org.eclipse.xtext@default:default,org.hamcrest.core@default:default,org.junit@default:default,org.objectweb.asm@default:default"/>
 <stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.room.tests@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.logging@default:false"/>
 <booleanAttribute key="show_selected_only" value="true"/>
+=======
+<stringAttribute key="selected_target_plugins" value="com.google.guava@default:default,com.google.inject@default:default,com.ibm.icu@default:default,javax.inject@default:default,javax.xml@default:default,org.antlr.runtime@default:default,org.apache.batik.css@default:default,org.apache.batik.util.gui@default:default,org.apache.batik.util@default:default,org.apache.commons.jxpath@default:default,org.apache.log4j@default:default,org.eclipse.ant.core@default:default,org.eclipse.compare.core@default:default,org.eclipse.core.commands@default:default,org.eclipse.core.contenttype@default:default,org.eclipse.core.databinding.observable@default:default,org.eclipse.core.databinding.property@default:default,org.eclipse.core.databinding@default:default,org.eclipse.core.expressions@default:default,org.eclipse.core.filesystem.win32.x86_64@default:false,org.eclipse.core.filesystem@default:default,org.eclipse.core.jobs@default:default,org.eclipse.core.resources.win32.x86_64@default:false,org.eclipse.core.resources@default:default,org.eclipse.core.runtime@default:true,org.eclipse.core.variables@default:default,org.eclipse.e4.core.commands@default:default,org.eclipse.e4.core.contexts@default:default,org.eclipse.e4.core.di.annotations@default:default,org.eclipse.e4.core.di.extensions@default:default,org.eclipse.e4.core.di@default:default,org.eclipse.e4.core.services@default:default,org.eclipse.e4.emf.xpath@default:default,org.eclipse.e4.ui.bindings@default:default,org.eclipse.e4.ui.css.core@default:default,org.eclipse.e4.ui.css.swt.theme@default:default,org.eclipse.e4.ui.css.swt@default:default,org.eclipse.e4.ui.di@default:default,org.eclipse.e4.ui.model.workbench@default:default,org.eclipse.e4.ui.services@default:default,org.eclipse.e4.ui.widgets@default:default,org.eclipse.e4.ui.workbench.addons.swt@default:default,org.eclipse.e4.ui.workbench.renderers.swt@default:default,org.eclipse.e4.ui.workbench.swt@default:default,org.eclipse.e4.ui.workbench3@default:default,org.eclipse.e4.ui.workbench@default:default,org.eclipse.emf.common@default:default,org.eclipse.emf.ecore.change@default:default,org.eclipse.emf.ecore.xmi@default:default,org.eclipse.emf.ecore@default:default,org.eclipse.equinox.app@default:default,org.eclipse.equinox.common@2:true,org.eclipse.equinox.preferences@default:default,org.eclipse.equinox.registry@default:default,org.eclipse.help@default:default,org.eclipse.jface.databinding@default:default,org.eclipse.jface@default:default,org.eclipse.osgi.compatibility.state@default:false,org.eclipse.osgi.services@default:default,org.eclipse.osgi@-1:true,org.eclipse.swt.win32.win32.x86_64@default:false,org.eclipse.swt@default:default,org.eclipse.team.core@default:default,org.eclipse.ui.trace@default:default,org.eclipse.ui.workbench@default:default,org.eclipse.ui@default:default,org.eclipse.xtend.core@default:default,org.eclipse.xtend.lib.macro@default:default,org.eclipse.xtend.lib@default:default,org.eclipse.xtext.common.types@default:default,org.eclipse.xtext.logging@default:false,org.eclipse.xtext.smap@default:default,org.eclipse.xtext.util@default:default,org.eclipse.xtext.xbase.lib@default:default,org.eclipse.xtext.xbase@default:default,org.eclipse.xtext@default:default,org.hamcrest.core@default:default,org.junit@default:default,org.objectweb.asm@default:default,org.w3c.css.sac@default:default,org.w3c.dom.events@default:default,org.w3c.dom.smil@default:default,org.w3c.dom.svg@default:default"/>
+<stringAttribute key="selected_workspace_plugins" value="org.eclipse.etrice.core.common@default:default,org.eclipse.etrice.core.fsm@default:default,org.eclipse.etrice.core.genmodel.fsm@default:default,org.eclipse.etrice.core.room.tests@default:default,org.eclipse.etrice.core.room@default:default,org.eclipse.etrice.logging@default:false"/>
+<booleanAttribute key="show_selected_only" value="false"/>
+>>>>>>> ff1be2e Bug 511330 - [core.genmodel.fsm] introduce simplified generator model for state machines
 <stringAttribute key="templateConfig" value="${target_home}\configuration\config.ini"/>
 <booleanAttribute key="tracing" value="false"/>
 <booleanAttribute key="useCustomFeatures" value="false"/>
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestAnnotations.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestAnnotations.java
index fa3d16e23..c65deeb25 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestAnnotations.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestAnnotations.java
@@ -28,7 +28,7 @@ public class TestAnnotations extends TestBase {
 	
 	@Before
 	public void SetUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		res = getResource("AnnotationExample.room");
 	}
 	
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBase.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBase.java
index ee8f39db1..1f358ba29 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBase.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBase.java
@@ -28,6 +28,7 @@ import org.eclipse.xtext.util.CancelIndicator;
 import org.eclipse.xtext.validation.CancelableDiagnostician;
 import org.eclipse.xtext.validation.CheckMode;
 import org.eclipse.xtext.validation.impl.ConcreteSyntaxEValidator;
+import org.osgi.framework.Bundle;
 
 import com.google.common.collect.Maps;
 
@@ -41,9 +42,9 @@ public class TestBase {
 
 	private String basePath;
 
-	protected void prepare() {
+	protected void prepare(Bundle bundle) {
 		try {
-			URL modelsDir = CoreTestsActivator.getInstance().getBundle().getEntry("models");
+			URL modelsDir = bundle.getEntry("models");
 			URL fileURL = FileLocator.toFileURL(modelsDir);
 			basePath = fileURL.getFile();
 		} catch (IOException e) {
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBindings.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBindings.java
index ee1dc26fc..d5d7ae50b 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBindings.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBindings.java
@@ -33,7 +33,7 @@ public class TestBindings extends TestBase {
 
 	@Before
 	public void setUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		
 		resource = getResource("TestBindings.room");
 	}
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBug505406.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBug505406.java
index f0044dd58..262029e7a 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBug505406.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestBug505406.java
@@ -29,7 +29,7 @@ public class TestBug505406 extends TestBase {
 
 	@Before
 	public void SetUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		res = getResource("bug505406.room");
 	}
 
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestCases.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestCases.java
index 8030130c0..769ffc253 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestCases.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestCases.java
@@ -31,7 +31,7 @@ public class TestCases extends TestBase {
 
 	@Before
 	public void setUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		
 		resource = getResource("test.room");
 	}
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestDynamicActors.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestDynamicActors.java
index 163223420..f4af08991 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestDynamicActors.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestDynamicActors.java
@@ -34,7 +34,7 @@ public class TestDynamicActors extends TestBase {
 
 	@Before
 	public void setUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		
 		resource = getResource("TestDynamicActors.room");
 	}
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestEnumerations.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestEnumerations.java
index adc68f457..1b50a282c 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestEnumerations.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestEnumerations.java
@@ -32,7 +32,7 @@ public class TestEnumerations extends TestBase {
 
 	@Before
 	public void SetUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		res = getResource("EnumExample.room");
 	}
 
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestFragments.java b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestFragments.java
index b448a38a8..b94063609 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestFragments.java
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestFragments.java
@@ -31,7 +31,7 @@ public class TestFragments extends TestBase {
 
 	@Before
 	public void setUp() {
-		prepare();
+		prepare(CoreTestsActivator.getInstance().getBundle());
 		
 		resource = getResource("ChoicePointTest.room");
 	}
diff --git a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestNames.xtend b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestNames.xtend
index 170c8aa5b..bc7f587b7 100644
--- a/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestNames.xtend
+++ b/tests/org.eclipse.etrice.core.room.tests/src/org/eclipse/etrice/core/TestNames.xtend
@@ -25,12 +25,12 @@ import org.junit.Test
 class TestNames extends TestBase {
 
 	val Map<EObject, Boolean> nameErrorMap = Maps.newHashMap
-	Resource res;
+	Resource res
 
 	@Before
 	def void SetUp() {
-		prepare();
-		res = getResource("NamesAreUnique.room");
+		prepare(CoreTestsActivator.getInstance().getBundle())
+		res = getResource("NamesAreUnique.room")
 		
 		val model = res.contents.head
 		val diag = getDiag(model)
@@ -61,7 +61,7 @@ class TestNames extends TestBase {
 		val items = newArrayList(ac, dc)
 		items += ac.eContents
 		items += dc.eContents
-		Assert.assertEquals("Unexpected item count", 15, items.size);
+		Assert.assertEquals("Unexpected item count", 15, items.size)
 		items.forEach[
 			Assert.assertFalse("expected no name error: " + it, it.hasNameErrorMessage)
 		]
@@ -75,7 +75,7 @@ class TestNames extends TestBase {
 		val items = newArrayList(ac, dc)
 		items += ac.eContents
 		items += dc.eContents
-		Assert.assertEquals("Unexpected item count", 9, items.size);
+		Assert.assertEquals("Unexpected item count", 9, items.size)
 		items.forEach[
 			Assert.assertFalse("expected no name error: " + it, it.hasNameErrorMessage)
 		]
@@ -89,7 +89,7 @@ class TestNames extends TestBase {
 		val items = newArrayList()
 		items += ac.eContents.filter[!(it instanceof ExternalPort)]
 		items += dc.eContents
-		Assert.assertEquals("Unexpected item count", 13, items.size);
+		Assert.assertEquals("Unexpected item count", 13, items.size)
 		items.forEach[
 			Assert.assertTrue("expected name error: " + it, it.hasNameErrorMessage)
 		]
@@ -109,7 +109,7 @@ class TestNames extends TestBase {
 		items += lc.eContents
 		items += sc.eContents
 		items += enum.eContents
-		Assert.assertEquals("Unexpected item count", 16, items.size);
+		Assert.assertEquals("Unexpected item count", 16, items.size)
 		items.forEach[
 			Assert.assertTrue("expected name error: " + it, it.hasNameErrorMessage)
 		]
@@ -121,6 +121,6 @@ class TestNames extends TestBase {
 
 	protected def boolean isNameErrorMessage(Diagnostic diag) {
 		val message = diag.message
-		return diag.severity >= Diagnostic.ERROR && (message.contains("Duplicate name") || (message.contains("Name") && message.contains("is already assigned to")));
+		return diag.severity >= Diagnostic.ERROR && (message.contains("Duplicate name") || (message.contains("Name") && message.contains("is already assigned to")))
 	}
 }
diff --git a/tests/org.eclipse.etrice.core.room.tests/xtend-gen/org/eclipse/etrice/core/TestNames.java b/tests/org.eclipse.etrice.core.room.tests/xtend-gen/org/eclipse/etrice/core/TestNames.java
new file mode 100644
index 000000000..37641c0ed
--- /dev/null
+++ b/tests/org.eclipse.etrice.core.room.tests/xtend-gen/org/eclipse/etrice/core/TestNames.java
@@ -0,0 +1,156 @@
+/**
+ * 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.core;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.CoreTestsActivator;
+import org.eclipse.etrice.core.TestBase;
+import org.eclipse.etrice.core.room.ExternalPort;
+import org.eclipse.xtext.validation.AbstractValidationDiagnostic;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestNames extends TestBase {
+  private final Map<EObject, Boolean> nameErrorMap = Maps.<EObject, Boolean>newHashMap();
+  
+  private Resource res;
+  
+  @Before
+  public void SetUp() {
+    this.prepare(CoreTestsActivator.getInstance().getBundle());
+    this.res = this.getResource("NamesAreUnique.room");
+    final EObject model = IterableExtensions.<EObject>head(this.res.getContents());
+    final Diagnostic diag = this.getDiag(model);
+    final Consumer<Diagnostic> _function = (Diagnostic it) -> {
+      if ((it instanceof AbstractValidationDiagnostic)) {
+        final EObject obj = ((AbstractValidationDiagnostic)it).getSourceEObject();
+        Boolean nameError = this.nameErrorMap.get(obj);
+        boolean _equals = Objects.equal(nameError, null);
+        if (_equals) {
+          nameError = Boolean.valueOf(false);
+        }
+        this.nameErrorMap.put(obj, Boolean.valueOf(((nameError).booleanValue() || this.isNameErrorMessage(it))));
+      }
+    };
+    diag.getChildren().forEach(_function);
+  }
+  
+  @Test
+  public void RoomClassNames() {
+    Assert.assertTrue(this.hasNameErrorMessage(this.res.getEObject("ActorClass:ClassDuplicate1")));
+    Assert.assertTrue(this.hasNameErrorMessage(this.res.getEObject("LogicalSystem:ClassDuplicate1")));
+    Assert.assertTrue(this.hasNameErrorMessage(this.res.getEObject("AnnotationType:ClassDuplicate1")));
+    Assert.assertTrue(this.hasNameErrorMessage(this.res.getEObject("EnumerationType:ClassDuplicate1")));
+    Assert.assertTrue(this.hasNameErrorMessage(this.res.getEObject("PrimitiveType:ClassDuplicate1")));
+  }
+  
+  @Test
+  public void BaseClassNames() {
+    final EObject ac = this.res.getEObject("ActorClass:Base");
+    final EObject dc = this.res.getEObject("DataClass:DBase");
+    final ArrayList<EObject> items = CollectionLiterals.<EObject>newArrayList(ac, dc);
+    EList<EObject> _eContents = ac.eContents();
+    Iterables.<EObject>addAll(items, _eContents);
+    EList<EObject> _eContents_1 = dc.eContents();
+    Iterables.<EObject>addAll(items, _eContents_1);
+    Assert.assertEquals("Unexpected item count", 15, items.size());
+    final Consumer<EObject> _function = (EObject it) -> {
+      Assert.assertFalse(("expected no name error: " + it), this.hasNameErrorMessage(it));
+    };
+    items.forEach(_function);
+  }
+  
+  @Test
+  public void OverrideNames() {
+    final EObject ac = this.res.getEObject("ActorClass:Override");
+    final EObject dc = this.res.getEObject("DataClass:DOverride");
+    final ArrayList<EObject> items = CollectionLiterals.<EObject>newArrayList(ac, dc);
+    EList<EObject> _eContents = ac.eContents();
+    Iterables.<EObject>addAll(items, _eContents);
+    EList<EObject> _eContents_1 = dc.eContents();
+    Iterables.<EObject>addAll(items, _eContents_1);
+    Assert.assertEquals("Unexpected item count", 9, items.size());
+    final Consumer<EObject> _function = (EObject it) -> {
+      Assert.assertFalse(("expected no name error: " + it), this.hasNameErrorMessage(it));
+    };
+    items.forEach(_function);
+  }
+  
+  @Test
+  public void InheritedNames() {
+    final EObject ac = this.res.getEObject("ActorClass:Sub");
+    final EObject dc = this.res.getEObject("DataClass:DSub");
+    final ArrayList<EObject> items = CollectionLiterals.<EObject>newArrayList();
+    final Function1<EObject, Boolean> _function = (EObject it) -> {
+      return Boolean.valueOf((!(it instanceof ExternalPort)));
+    };
+    Iterable<EObject> _filter = IterableExtensions.<EObject>filter(ac.eContents(), _function);
+    Iterables.<EObject>addAll(items, _filter);
+    EList<EObject> _eContents = dc.eContents();
+    Iterables.<EObject>addAll(items, _eContents);
+    Assert.assertEquals("Unexpected item count", 13, items.size());
+    final Consumer<EObject> _function_1 = (EObject it) -> {
+      Assert.assertTrue(("expected name error: " + it), this.hasNameErrorMessage(it));
+    };
+    items.forEach(_function_1);
+  }
+  
+  @Test
+  public void FlatNames() {
+    final EObject ac = this.res.getEObject("ActorClass:Flat");
+    final EObject dc = this.res.getEObject("DataClass:DFlat");
+    final EObject lc = this.res.getEObject("DataClass:LFlat");
+    final EObject sc = this.res.getEObject("DataClass:SFlat");
+    final EObject enum_ = this.res.getEObject("DataClass:EnumFlat");
+    final ArrayList<EObject> items = CollectionLiterals.<EObject>newArrayList();
+    final Function1<EObject, Boolean> _function = (EObject it) -> {
+      return Boolean.valueOf((!(it instanceof ExternalPort)));
+    };
+    Iterable<EObject> _filter = IterableExtensions.<EObject>filter(ac.eContents(), _function);
+    Iterables.<EObject>addAll(items, _filter);
+    EList<EObject> _eContents = dc.eContents();
+    Iterables.<EObject>addAll(items, _eContents);
+    EList<EObject> _eContents_1 = lc.eContents();
+    Iterables.<EObject>addAll(items, _eContents_1);
+    EList<EObject> _eContents_2 = sc.eContents();
+    Iterables.<EObject>addAll(items, _eContents_2);
+    EList<EObject> _eContents_3 = enum_.eContents();
+    Iterables.<EObject>addAll(items, _eContents_3);
+    Assert.assertEquals("Unexpected item count", 16, items.size());
+    final Consumer<EObject> _function_1 = (EObject it) -> {
+      Assert.assertTrue(("expected name error: " + it), this.hasNameErrorMessage(it));
+    };
+    items.forEach(_function_1);
+  }
+  
+  private boolean hasNameErrorMessage(final EObject obj) {
+    return (this.nameErrorMap.containsKey(obj) && (this.nameErrorMap.get(obj)).booleanValue());
+  }
+  
+  protected boolean isNameErrorMessage(final Diagnostic diag) {
+    final String message = diag.getMessage();
+    return ((diag.getSeverity() >= Diagnostic.ERROR) && (message.contains("Duplicate name") || (message.contains("Name") && message.contains("is already assigned to"))));
+  }
+}
diff --git a/tests/org.eclipse.etrice.generator.c.tests/.gitignore b/tests/org.eclipse.etrice.generator.c.tests/.gitignore
index b45c5f774..57f15dea9 100644
--- a/tests/org.eclipse.etrice.generator.c.tests/.gitignore
+++ b/tests/org.eclipse.etrice.generator.c.tests/.gitignore
@@ -1 +1,7 @@
-src-gen/
\ No newline at end of file
+src-gen/
+bin
+models
+output
+results
+src-gen
+log
diff --git a/tests/org.eclipse.etrice.generator.c.tests/org.eclipse.etrice.generator.c.tests make.xml.launch b/tests/org.eclipse.etrice.generator.c.tests/org.eclipse.etrice.generator.c.tests make.xml.launch
new file mode 100644
index 000000000..82407cfc0
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.c.tests/org.eclipse.etrice.generator.c.tests make.xml.launch
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.ant.AntLaunchConfigurationType">
+<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${project}"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES"/>
+<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
+<listEntry value="org.eclipse.ui.externaltools.launchGroup"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.c.tests"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<mapAttribute key="org.eclipse.ui.externaltools.ATTR_ANT_PROPERTIES">
+<mapEntry key="com.google.guava" value="${target_platform_plugin_location:com.google.guava}"/>
+<mapEntry key="com.google.inject" value="${target_platform_plugin_location:com.google.inject}"/>
+<mapEntry key="eclipse.home" value="${eclipse_home}"/>
+<mapEntry key="eclipse.pdebuild.home" value="${target_platform_plugin_location:org.eclipse.pde.build}"/>
+<mapEntry key="eclipse.pdebuild.scripts" value="${target_platform_plugin_location:org.eclipse.pde.build}/scripts/"/>
+<mapEntry key="eclipse.pdebuild.templates" value="${target_platform_plugin_location:org.eclipse.pde.build}/templates/"/>
+<mapEntry key="eclipse.running" value="true"/>
+<mapEntry key="javax.inject" value="${target_platform_plugin_location:javax.inject}"/>
+<mapEntry key="org.antlr.runtime" value="${target_platform_plugin_location:org.antlr.runtime}"/>
+<mapEntry key="org.apache.log4j" value="${target_platform_plugin_location:org.apache.log4j}"/>
+<mapEntry key="org.eclipse.emf.common" value="${target_platform_plugin_location:org.eclipse.emf.common}"/>
+<mapEntry key="org.eclipse.emf.ecore" value="${target_platform_plugin_location:org.eclipse.emf.ecore}"/>
+<mapEntry key="org.eclipse.emf.ecore.xmi" value="${target_platform_plugin_location:org.eclipse.emf.ecore.xmi}"/>
+<mapEntry key="org.eclipse.equinox.common" value="${target_platform_plugin_location:org.eclipse.equinox.common}"/>
+<mapEntry key="org.eclipse.xtend.lib" value="${target_platform_plugin_location:org.eclipse.xtend.lib}"/>
+<mapEntry key="org.eclipse.xtext" value="${target_platform_plugin_location:org.eclipse.xtext}"/>
+<mapEntry key="org.eclipse.xtext.common.types" value="${target_platform_plugin_location:org.eclipse.xtext.common.types}"/>
+<mapEntry key="org.eclipse.xtext.util" value="${target_platform_plugin_location:org.eclipse.xtext.util}"/>
+<mapEntry key="org.eclipse.xtext.xbase.lib" value="${target_platform_plugin_location:org.eclipse.xtext.xbase.lib}"/>
+</mapAttribute>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LAUNCH_CONFIGURATION_BUILD_SCOPE" value="${none}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/org.eclipse.etrice.generator.c.tests/make.xml}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS" value="-v"/>
+<stringAttribute key="process_factory_id" value="org.eclipse.ant.ui.remoteAntProcessFactory"/>
+</launchConfiguration>
diff --git a/tests/org.eclipse.etrice.generator.common.tests/common.xml b/tests/org.eclipse.etrice.generator.common.tests/common.xml
new file mode 100644
index 000000000..90d29d8a0
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.common.tests/common.xml
@@ -0,0 +1,219 @@
+
+<?xml version="1.0"?>
+<project name="org.eclipse.etrice.generator.common.tests">
+
+	<target name="testing" depends="copyModels">
+
+		<!-- add test here, testid==testSuiteFileName -->
+		<test testid="ActorCommunicationTest" models="${models.path}/ActorCommunicationTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="ChoicePointTest" models="${models.path}/ChoicePointTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="ChoicePointTestExtended" models="${models.path}/ChoicePointTestExtended.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DataDrivenTest" models="${models.path}/DataDrivenTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="EnumTest" models="${models.path}/EnumTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="CompileTests" models="${models.path}/CompileTests.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="HandlerTest" models="${models.path}/HandlerTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="OperationInheritanceTest" models="${models.path}/OperationInheritanceTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="PingPongThreadTest" models="${models.path}/PingPongThreadTest.etmap" />
+		<test testid="PingPongThreadReplPortTest" models="${models.path}/PingPongThreadReplPortTest.etmap" />
+
+
+		<echo>done with ${ant.project.name}</echo>
+	</target>
+
+	<target name="copyModels" depends="setVars">
+		<copy todir="${models.path}">
+			<fileset dir="../org.eclipse.etrice.generator.common.tests/models"/>
+		</copy>
+		<copy todir="${models.path}" >
+			<fileset dir="${modellib.path}/model">
+				<include name="*.room"/>
+				<include name="*.etphys"/>
+			</fileset>
+		</copy>
+	</target>
+
+	<!-- ################################################################ -->
+
+	<!-- global properties -->
+	<!-- test.results, target.platform -->
+
+	<!-- private properties-->
+	<property name="models.path" value="./models"/>
+	<property name="testlog.path" value="./log/testlog"/>
+	<property name="output" value="./output"/>
+	<property name="bin.path" value="./bin"/>
+
+	<property name="run.msTimout" value="5000"/>
+
+	<!-- show ALL used variables -->
+	<target name="showVars">
+		<echo>   ant.project.name               = ${ant.project.name}                 </echo>
+		<echo>   runtime.path                   = ${runtime.path}                     </echo>
+		<echo>   testlog.path                   = ${testlog.path}                     </echo>
+		<echo>   test.results                   = ${test.results}                     </echo>
+		<echo>   output                         = ${output}                           </echo>
+		<echo>   bin.path                       = ${bin.path}                         </echo>
+		<echo>   target.platform                = ${target.platform}                  </echo>
+		<echo>   modellib.path                  = ${modellib.path}                    </echo>
+		<echo>   models.path                    = ${models.path}                      </echo>
+		<echo>   basedir                        = ${basedir}                          </echo>
+		
+		<echo>   org.eclipse.emf.ecore          = ${org.eclipse.emf.ecore}            </echo>
+		<echo>   org.eclipse.emf.common         = ${org.eclipse.emf.common}           </echo>
+		<echo>   org.eclipse.emf.ecore.xmi      = ${org.eclipse.emf.ecore.xmi}        </echo>
+		<echo>   com.google.inject              = ${com.google.inject}                </echo>
+		<echo>   com.google.guava               = ${com.google.guava}                 </echo>
+		<echo>   org.eclipse.equinox.common     = ${org.eclipse.equinox.common}       </echo>
+		<echo>   org.eclipse.xtext              = ${org.eclipse.xtext}                </echo>
+        <echo>   org.eclipse.xtext.util         = ${org.eclipse.xtext.util}           </echo>
+		<echo>   org.eclipse.xtext.common.types = ${org.eclipse.xtext.common.types}   </echo>
+		<echo>   org.eclipse.xtend.lib          = ${org.eclipse.xtend.lib}            </echo>
+		<echo>   org.eclipse.xtext.xbase.lib    = ${org.eclipse.xtext.xbase.lib}      </echo>
+		<echo>   org.apache.log4j               = ${org.apache.log4j}                 </echo>
+		<echo>   org.antlr.runtime              = ${org.antlr.runtime}                </echo>
+		<echo>   javax.inject                   = ${javax.inject}                     </echo>
+		
+		<pathconvert property="classpathProp" refid="etrice.clspath"/>
+		<echo>   etrice.clspath                 = ${classpathProp}                    </echo>
+	</target>
+
+	<!-- set global properties if not set-->
+	<target name="set_local_tr" unless="test.results">
+		<property name="test.results" value="./results"/>
+	</target>
+	<target name="set_local_tp" unless="target.platform">
+		<property name="target.platform" value="${eclipse.home}"/>
+	</target>
+
+	<target name="setVars" depends="set_local_tp,set_local_tr,set_etrice_clspath,showVars"/>
+
+	<target name="set_etrice_clspath">
+		<path id="etrice.clspath">
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.c/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.java/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.cpp/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.etunit.converter/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.config/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.doc/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.fsm/bin" />
+			<pathelement location="../../plugins/org.eclipse.etrice.generator/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.generator.gnuplot/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.common/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.fsm/bin" />
+			<pathelement location="../../plugins/org.eclipse.etrice.core.room/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.etphys/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.etmap/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.config/bin"/>
+			<pathelement location="../../plugins/org.eclipse.etrice.core.genmodel/bin" />
+			<pathelement location="../../plugins/org.eclipse.etrice.core.genmodel.fsm/bin" />
+			<pathelement location="../../plugins/org.eclipse.etrice.core.genmodel/bin"/>
+			
+			<!-- resolve dependencies using Oomph util in properties of launch config -->
+			<pathelement location="${org.eclipse.emf.ecore}"/>
+			<pathelement location="${org.eclipse.emf.common}"/>
+			<pathelement location="${org.eclipse.emf.ecore.xmi}"/>
+			<pathelement location="${com.google.inject}"/>
+			<pathelement location="${com.google.guava}"/>
+			<pathelement location="${org.eclipse.equinox.common}"/>
+			<pathelement location="${org.eclipse.xtext}"/>
+			<pathelement location="${org.eclipse.xtext.util}"/>
+			<pathelement location="${org.eclipse.xtext.common.types}"/>
+			<pathelement location="${org.eclipse.xtend.lib}"/>
+			<pathelement location="${org.eclipse.xtext.xbase.lib}"/>
+			<pathelement location="${org.apache.log4j}"/>
+			<pathelement location="${org.antlr.runtime}"/>
+			<pathelement location="${javax.inject}"/>
+			
+			<!-- resolve if used from Buckminster Ant task -->
+			<fileset dir="${target.platform}/plugins/">
+				<include name="org.eclipse.emf.ecore_2.1*.jar" />
+				<include name="org.eclipse.emf.common_2.1*.jar" />
+				<include name="org.eclipse.emf.ecore.xmi_2.1*.jar" />
+				<include name="com.google.inject_*.jar" />
+				<include name="com.google.guava_1*.jar" />
+				<include name="org.eclipse.equinox.common_3.*.jar" />
+				<include name="org.apache.log4j_1.2*.jar" />
+				<include name="org.antlr.runtime_3.2*.jar" />
+				<include name="javax.inject_1.0*.jar" />
+
+				<!-- Xtext 2.6 -->
+				<include name="org.eclipse.xtext_2.6*.jar" />
+				<include name="org.eclipse.xtext.util_2.6*.jar" />
+				<include name="org.eclipse.xtext.common.types_2.6*.jar" />
+				<include name="org.eclipse.xtend.lib_2.6*.jar" />
+				<include name="org.eclipse.xtext.xbase.lib_2.6*.jar" />
+
+				<!-- Xtext 2.7 -->
+				<include name="org.eclipse.xtext_2.7*.jar" />
+				<include name="org.eclipse.xtext.util_2.7*.jar" />
+				<include name="org.eclipse.xtext.common.types_2.7*.jar" />
+				<include name="org.eclipse.xtend.lib_2.7*.jar" />
+				<include name="org.eclipse.xtext.xbase.lib_2.7*.jar" />
+
+				<!-- Xtext 2.8 -->
+				<include name="org.eclipse.xtext_2.8*.jar" />
+				<include name="org.eclipse.xtext.util_2.8*.jar" />
+				<include name="org.eclipse.xtext.common.types_2.8*.jar" />
+				<include name="org.eclipse.xtend.lib_2.8*.jar" />
+				<include name="org.eclipse.xtext.xbase.lib_2.8*.jar" />
+
+				<!-- Xtext 2.10 -->
+				<include name="org.eclipse.xtext_2.10*.jar" />
+				<include name="org.eclipse.xtext.util_2.10*.jar" />
+				<include name="org.eclipse.xtext.common.types_2.10*.jar" />
+				<include name="org.eclipse.xtend.lib_2.10*.jar" />
+				<include name="org.eclipse.xtext.xbase.lib_2.10*.jar" />
+			</fileset>
+		</path>
+	</target>
+
+	<!--
+		clean: deletes all folders created by this script
+	-->
+	<target name="clean" depends="setVars">
+		<delete dir="${testlog.path}"/>
+		<!--deletes resulst from other script on server <delete dir="${test.results}"/>-->
+		<delete dir="${output}"/>
+		<delete dir="${bin.path}"/>
+		<delete dir="${models.path}"/>
+		<delete dir="log"/>
+		<delete dir="src-gen"/>
+	</target>
+
+	<macrodef name="convert">
+		<attribute name="testId"/>
+		<sequential>
+			<java output="${output}/convert.txt" append="true" classname="org.eclipse.etrice.etunit.converter.EtUnitReportConverter" fork="true" failonerror="true">
+				<arg value="-suite"/>
+				<arg value="${ant.project.name}.@{testId}"/>
+				<arg value="${testlog.path}/@{testId}.etu"/>
+				<classpath refid="etrice.clspath"/>
+			</java>
+		</sequential>
+	</macrodef>
+	
+	<macrodef name="convertPre">
+		<attribute name="testId"/>
+		<sequential>
+			<java output="${output}/convert.txt" append="true" classname="org.eclipse.etrice.etunit.converter.EtUnitReportConverter" fork="true" failonerror="true">
+				<arg value="-presuite"/>
+				<arg value="${ant.project.name}."/>
+				<arg value="${testlog.path}/@{testId}.etu"/>
+				<classpath refid="etrice.clspath"/>
+			</java>
+		</sequential>
+	</macrodef>
+
+	<!--
+		copy_results: copies the *.xml results to their final destination
+	-->
+	<macrodef name="copyResult">
+		<attribute name="testId"/>
+		<attribute name="targetId" default=""/>
+		<sequential>
+			<mkdir dir="${test.results}"/>
+			<move file="${testlog.path}/@{testId}.xml" tofile="${test.results}/@{targetId}@{testId}.xml"/>
+		</sequential>
+	</macrodef>
+
+</project>
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/ActorCommunicationTest.room b/tests/org.eclipse.etrice.generator.common.tests/models/ActorCommunicationTest.room
index 9b51b0972..8948c557d 100644
--- a/tests/org.eclipse.etrice.generator.common.tests/models/ActorCommunicationTest.room
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/ActorCommunicationTest.room
@@ -122,7 +122,7 @@ RoomModel ActorCommunicationTest {
 					}
 					action {
 
-					//"System.out.println(\"Finish data\");"
+					//"System.out.println(\"Finish transitionData\");"
 						"data_finish_flag = true;"
 						"EXPECT_ORDER_END(data_caseId,\"<|MODEL_LOCATION|>\", 10);"
 						"etUnit_closeTestCase(data_caseId);"
@@ -178,18 +178,18 @@ RoomModel ActorCommunicationTest {
 					action {
 						"counter = data_counter.in1;"
 
-						//"System.out.println(\"Async data \"+counter);"
+						//"System.out.println(\"Async transitionData \"+counter);"
 						"EXPECT_ORDER(data_counter.caseId,\"<|MODEL_LOCATION|>\", counter + 1050);"
 					}
 				}
 				Transition tr1: Idle -> Idle {
 					triggers {
 						<in1: event_counter guard {
-							"data % 2 == 0 && data < 10"
+							"transitionData % 2 == 0 && transitionData < 10"
 						}>
 					}
 					action {
-						"counter = data;"
+						"counter = transitionData;"
 
 						//"System.out.println(\"Async event \"+counter);"
 						"EXPECT_ORDER(data_counter.caseId,\"<|MODEL_LOCATION|>\", counter + 1000);"
@@ -198,7 +198,7 @@ RoomModel ActorCommunicationTest {
 				Transition tr2: Idle -> state0 {
 					triggers {
 						<in1: event_counter guard {
-							"data == 10"
+							"transitionData == 10"
 						}>
 					}
 					action {
@@ -230,19 +230,19 @@ RoomModel ActorCommunicationTest {
 				Transition tr0: state0 -> state0 {
 					triggers {
 						<in1: event_counter guard {
-							"data < 10"
+							"transitionData < 10"
 						}>
 					}
 					action {
 
-					//"System.out.println(\"event \"+data);"
-						"EXPECT_ORDER(caseId, \"<|MODEL_LOCATION|>\", data+100);"
+					//"System.out.println(\"event \"+transitionData);"
+						"EXPECT_ORDER(caseId, \"<|MODEL_LOCATION|>\", transitionData+100);"
 					}
 				}
 				Transition tr1: state0 -> state1 {
 					triggers {
 						<in1: event_counter guard {
-							"data == 10"
+							"transitionData == 10"
 						}>
 					}
 					action {
@@ -254,7 +254,7 @@ RoomModel ActorCommunicationTest {
 						<caseId: event_counter>
 					}
 					action {
-						"caseId = data;"
+						"caseId = transitionData;"
 					}
 				}
 				State state0
@@ -296,7 +296,7 @@ RoomModel ActorCommunicationTest {
 					action {
 						"counter = data_counter.in1;"
 
-						//"System.out.println(\"data \"+counter);"
+						//"System.out.println(\"transitionData \"+counter);"
 						"EXPECT_ORDER(data_counter.caseId, \"<|MODEL_LOCATION|>\", counter);"
 					}
 				}
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/ChoicePointTestExtended.room b/tests/org.eclipse.etrice.generator.common.tests/models/ChoicePointTestExtended.room
index fe184e51e..4eebae58f 100644
--- a/tests/org.eclipse.etrice.generator.common.tests/models/ChoicePointTestExtended.room
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/ChoicePointTestExtended.room
@@ -29,7 +29,7 @@ RoomModel ChoicePointTestExtended {
 						<testInitialCP0: testPort0>
 					}
 					action {
-						"testValue = value;"
+						"testValue = transitionData;"
 					}
 				}
 				Transition tr1: waiting -> waiting {
@@ -37,7 +37,7 @@ RoomModel ChoicePointTestExtended {
 						<setCaseId: navPort>
 					}
 					action {
-						"caseId = id;"
+						"caseId = transitionData;"
 					}
 				}
 				State testSubState {
@@ -59,7 +59,7 @@ RoomModel ChoicePointTestExtended {
 								<testTrCP0: testPort0>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 							}
 						}
 						
@@ -68,7 +68,7 @@ RoomModel ChoicePointTestExtended {
 								<testTrCP0: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 							}
 						}
 						Transition tr7: my tp0 -> cp cp0 {
@@ -76,7 +76,7 @@ RoomModel ChoicePointTestExtended {
 								<testTrCP1: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 							}
 						}
 						
@@ -120,7 +120,7 @@ RoomModel ChoicePointTestExtended {
 						Transition tr4: my tp1 -> simpleState {
 							triggers {
 								<toNode: navPort guard {
-									"id == 1"
+									"transitionData == 1"
 								}>
 							}
 						}
@@ -129,7 +129,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort0>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(10);"
 								"navPort.onMessage(100);"
@@ -140,7 +140,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(100);"
@@ -151,7 +151,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP1: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(101);"
@@ -162,7 +162,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort0>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(10);"
 								"navPort.onMessage(100);"
@@ -173,7 +173,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(100);"
@@ -184,7 +184,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP1: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(101);"
@@ -193,14 +193,14 @@ RoomModel ChoicePointTestExtended {
 						Transition tr13: my tp1 -> subState {
 							triggers {
 								<toNode: navPort guard {
-									"id == 2"
+									"transitionData == 2"
 								}>
 							}
 						}
 						Transition tr14: my tp1 -> tp1 of exitPoints {
 							triggers {
 								<toNode: navPort guard {
-									"id == 3"
+									"transitionData == 3"
 								}>
 							}
 						}
@@ -208,7 +208,7 @@ RoomModel ChoicePointTestExtended {
 						Transition tr16: my tp1 -> choicePoint {
 							triggers {
 								<toNode: navPort guard {
-									"id==4"
+									"transitionData == 4"
 								}>
 							}
 						}
@@ -218,7 +218,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort0>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(10);"
 								"navPort.onMessage(100);"
@@ -239,7 +239,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP0: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(100);"
@@ -250,7 +250,7 @@ RoomModel ChoicePointTestExtended {
 								<testCP1: testPort1>
 							}
 							action {
-								"testValue = value;"
+								"testValue = transitionData;"
 								""
 								"navPort.onProtocol(11);"
 								"navPort.onMessage(101);"
@@ -280,7 +280,7 @@ RoomModel ChoicePointTestExtended {
 										<testCP0: testPort0>
 									}
 									action {
-										"testValue = value;"
+										"testValue = transitionData;"
 										""
 										"navPort.onProtocol(10);"
 										"navPort.onMessage(100);"
@@ -291,7 +291,7 @@ RoomModel ChoicePointTestExtended {
 										<testCP0: testPort1>
 									}
 									action {
-										"testValue = value;"
+										"testValue = transitionData;"
 										""
 										"navPort.onProtocol(11);"
 										"navPort.onMessage(100);"
@@ -302,7 +302,7 @@ RoomModel ChoicePointTestExtended {
 										<testCP1: testPort1>
 									}
 									action {
-										"testValue = value;"
+										"testValue = transitionData;"
 										""
 										"navPort.onProtocol(11);"
 										"navPort.onMessage(101);"
@@ -406,7 +406,7 @@ RoomModel ChoicePointTestExtended {
 						<resultCP: navPort>
 					}
 					action {
-						"check(value);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr7: testTr -> testTr1 {
@@ -414,7 +414,7 @@ RoomModel ChoicePointTestExtended {
 						<resultCP: navPort>
 					}
 					action {
-						"check(value);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr8: testTr1 -> testTr2 {
@@ -422,7 +422,7 @@ RoomModel ChoicePointTestExtended {
 						<resultCP: navPort>
 					}
 					action {
-						"check(value);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr1: testTr2 -> triggerTest {
@@ -430,7 +430,7 @@ RoomModel ChoicePointTestExtended {
 						<onNode: navPort>
 					}
 					action {
-						"check(id);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr4: testPath -> testPath {
@@ -438,7 +438,7 @@ RoomModel ChoicePointTestExtended {
 						<onMessage: navPort>
 					}
 					action {
-						"check(id);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr5: testPath -> onCP {
@@ -446,7 +446,7 @@ RoomModel ChoicePointTestExtended {
 						<resultCP: navPort>
 					}
 					action {
-						"check(value);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr9: onCP -> triggerTest {
@@ -454,7 +454,7 @@ RoomModel ChoicePointTestExtended {
 						<onNode: navPort>
 					}
 					action {
-						"check(id);"
+						"check(transitionData);"
 					}
 				}
 				Transition tr10: triggerTest -> testPath {
@@ -462,7 +462,7 @@ RoomModel ChoicePointTestExtended {
 						<onProtocol: navPort>
 					}
 					action {
-						"check(id);"
+						"check(transitionData);"
 					}
 				}
 				State testInitial {
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/ContinuationTransitionTest.room b/tests/org.eclipse.etrice.generator.common.tests/models/ContinuationTransitionTest.room
index e17ab03dd..516c50d1e 100644
--- a/tests/org.eclipse.etrice.generator.common.tests/models/ContinuationTransitionTest.room
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/ContinuationTransitionTest.room
@@ -93,7 +93,7 @@ RoomModel ContinuationTransitionTest {
 				}
 				Transition continuationExit: exitPoint of substate -> endExit {
 					action {
-						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, data);"
+						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, transitionData);"
 					}
 				}
 				Transition tr0: startEntry2 -> entryPoint of substate {
@@ -106,7 +106,7 @@ RoomModel ContinuationTransitionTest {
 					subgraph {
 						Transition continuationEntry: my entryPoint -> cp choicePoint {
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition triggerExit: startExit1 -> my exitPoint {
@@ -116,7 +116,7 @@ RoomModel ContinuationTransitionTest {
 						}
 						Transition continuationCpElse: cp choicePoint -> startExit1 {
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition continuationCpCond: cp choicePoint -> startExit2 {
@@ -124,7 +124,7 @@ RoomModel ContinuationTransitionTest {
 								"true"
 							}
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition triggerChoicePoint: my startChoicePoint -> cp choicePoint {
@@ -166,7 +166,7 @@ RoomModel ContinuationTransitionTest {
 				}
 				Transition continuationExit: exitPoint of substate -> endExit {
 					action {
-						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, data);"
+						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, transitionData);"
 					}
 				}
 				Transition tr0: startEntry2 -> entryPoint of substate {
@@ -179,7 +179,7 @@ RoomModel ContinuationTransitionTest {
 					subgraph {
 						Transition continuationEntry: my entryPoint -> cp choicePoint {
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition triggerExit: startExit1 -> my exitPoint {
@@ -189,7 +189,7 @@ RoomModel ContinuationTransitionTest {
 						}
 						Transition continuationCpElse: cp choicePoint -> startExit1 {
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition continuationCpCond: cp choicePoint -> startExit2 {
@@ -197,7 +197,7 @@ RoomModel ContinuationTransitionTest {
 								"true"
 							}
 							action {
-								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, data);"
+								"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 1, transitionData);"
 							}
 						}
 						Transition triggerChoicePoint: my startChoicePoint -> cp choicePoint {
@@ -311,7 +311,7 @@ RoomModel ContinuationTransitionTest {
 				}
 				Transition tr1: cp cp0 -> state1 {
 					action {
-						"int x = data1;"
+						"int x = transitionData;"
 					}
 				}
 				Transition tr2: cp cp0 -> state2 {
@@ -319,7 +319,7 @@ RoomModel ContinuationTransitionTest {
 						"true"
 					}
 					action {
-						"int x = data1;"
+						"int x = transitionData;"
 					}
 				}
 				ChoicePoint cp0
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/DetailExpressionTest.room b/tests/org.eclipse.etrice.generator.common.tests/models/DetailExpressionTest.room
index a3297bce9..2ff8d6533 100644
--- a/tests/org.eclipse.etrice.generator.common.tests/models/DetailExpressionTest.room
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/DetailExpressionTest.room
@@ -29,7 +29,12 @@ RoomModel DetailExpressionTestModel {
 					triggers {
 						<out1: cPortEvent guard {
 							"/* TODO activate action code editor */"
+<<<<<<< Upstream, based on origin/master
 							"rPortData.in1 == numberArray[3] && accessibleMessageData && infoData.flag && actorOp(32)  && rPortEvent.regularOp(32) && cPortEvent.conjugatedOp(32)"
+=======
+							"rPortData.in1 == numberArray[3] &&"
+							"transitionData && infoData.flag"
+>>>>>>> ff1be2e Bug 511330 - [core.genmodel.fsm] introduce simplified generator model for state machines
 						}>
 					}
 					action 
@@ -53,7 +58,7 @@ RoomModel DetailExpressionTestModel {
 						"int port = infoData.nested.tcpPort;"
 						""
 						"// transition event data"
-						"int data = (accessibleMessageData)? 1 : 0;"
+						"int data = (transitionData)? 1 : 0;"
 						""
 						"// -- not supported yet by code translation --"
 						"// getReplication():"
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/HandlerTest.room b/tests/org.eclipse.etrice.generator.common.tests/models/HandlerTest.room
index 381ad7633..a43e615f2 100644
--- a/tests/org.eclipse.etrice.generator.common.tests/models/HandlerTest.room
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/HandlerTest.room
@@ -43,7 +43,7 @@ RoomModel HandlerTest {
 				Transition tr1: my tp1 -> my tp1 {
 					triggers {
 						<msg1: TestPort1 guard {
-							"p1==3"
+							"transitionData==3"
 						}>
 					}
 					action {
@@ -58,7 +58,7 @@ RoomModel HandlerTest {
 				Transition tr9: state0 -> cp cp1 {
 					triggers {
 						<msg1: TestPort1 guard {
-							"p1==4"
+							"transitionData==4"
 						}>
 					}
 					action {
@@ -68,7 +68,7 @@ RoomModel HandlerTest {
 				Transition tr5: my tp1 -> my tp1 {
 					triggers {
 						<msg2: TestPort1 guard {
-							"p1==4"
+							"transitionData==4"
 						}>
 					}
 					action {
@@ -78,7 +78,7 @@ RoomModel HandlerTest {
 				Transition tr7: my tp0 -> state0 {
 					triggers {
 						<msg1: TestPort1 guard {
-							"p1==7"
+							"transitionData==7"
 						}>
 					}
 					action {
@@ -88,7 +88,7 @@ RoomModel HandlerTest {
 				Transition tr6: my tp0 -> my tp0 {
 					triggers {
 						<msg1: TestPort1 guard {
-							"p1==12"
+							"transitionData==12"
 						}>
 					}
 					action {
@@ -102,7 +102,7 @@ RoomModel HandlerTest {
 				}
 				Transition tr10: cp cp1 -> state0 {
 					cond {
-						"p1!=4"
+						"transitionData!=4"
 					}
 					action {
 						"EXPECT_ORDER(caseId, \"<|MODEL_LOCATION|>\", 115);"
@@ -164,7 +164,7 @@ RoomModel HandlerTest {
 						Transition tr5: my tp0 -> my tp0 {
 							triggers {
 								<msg1: TestPort1 guard {
-									"p1==5"
+									"transitionData==5"
 								}>
 							}
 							action {
@@ -179,7 +179,7 @@ RoomModel HandlerTest {
 						Transition tr6: state1 -> state1 {
 							triggers {
 								<msg1: TestPort1 guard {
-									"p1==8"
+									"transitionData==8"
 								}>
 							}
 							action {
@@ -189,7 +189,7 @@ RoomModel HandlerTest {
 						Transition tr7: my tp1 -> state1 {
 							triggers {
 								<msg2: TestPort1 guard {
-									"p1==5"
+									"transitionData==5"
 								}>
 							}
 							action {
@@ -199,7 +199,7 @@ RoomModel HandlerTest {
 						Transition tr8: my tp1 -> state2 {
 							triggers {
 								<msg2: TestPort1 guard {
-									"p1==6"
+									"transitionData==6"
 								}>
 							}
 							action {
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestCpp.room b/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestCpp.room
new file mode 100644
index 000000000..67e47ef7e
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestCpp.room
@@ -0,0 +1,605 @@
+RoomModel SendingDataTestCpp {
+
+	import room.basic.etunit.* from "../Tests.room"
+	import room.basic.types.* from "../Types.room"
+	import room.basic.language.* from "../Language.room"
+
+	ActorClass SendingDataTop {
+		@TestInstance
+		Structure {
+			ActorRef mrPing: MrPing
+			ActorRef mrPong: MrPong
+			Binding mrPong.PingPongPort and mrPing.PingPongPort
+		}
+		Behavior { }
+	}
+
+	ActorClass MrPong {
+		Interface {
+			Port PingPongPort: PingPongProtocol
+			Port extTest: PCExternal
+		}
+		Structure {
+			external Port PingPongPort
+			external Port extTest
+		}
+		Behavior {
+			StateMachine {
+				Transition tr0: reply -> reply {
+					triggers {
+						<pingInt16: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt16(transitionData);"
+					}
+				}
+				Transition tr1: reply -> reply {
+					triggers {
+						<pingInt8: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt8(transitionData);"
+					}
+				}
+				Transition init: initial -> reply { }
+				Transition tr2: reply -> reply {
+					triggers {
+						<pingInt32: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt32(transitionData);"
+					}
+				}
+				Transition tr3: reply -> reply {
+					triggers {
+						<pingFloat32: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongFloat32(transitionData);"
+					}
+				}
+				Transition tr4: reply -> reply {
+					triggers {
+						<pingFloat64: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongFloat64(transitionData);"
+					}
+				}
+				Transition tr7: reply -> cp cp0 {
+					triggers {
+						<pingInt32Ref: PingPongPort guard {
+							"(*transitionData)!=0"
+						}>
+					}
+				}
+				Transition tr8: cp cp0 -> reply {
+					action {
+						"PingPongPort.pongInt32((*transitionData)+10);"
+					}
+				}
+				Transition tr6: cp cp0 -> reply {
+					cond {
+						"(*transitionData)!=5"
+					}
+					action {
+						"PingPongPort.pongInt32(*transitionData);"
+					}
+				}
+				Transition tr9: reply -> reply {
+					triggers {
+						<pingComplex: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr11: reply -> reply {
+					triggers {
+						<pingComplexRef: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplex(*transitionData);"
+					}
+				}
+				Transition tr5: reply -> reply {
+					triggers {
+						<pingInt64: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt64(transitionData);"
+					}
+				}
+				Transition tr10: reply -> reply {
+					triggers {
+						<pingInt16Ref: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt16(*transitionData);"
+					}
+				}
+				Transition tr12: reply -> cp cp1 {
+					triggers {
+						<pingComplexRef: PingPongPort guard {
+							"transitionData->i8ValPPD == 5"
+						}>
+					}
+					action {
+						"PingPongPort.pongComplex(*transitionData);"
+					}
+				}
+				Transition tr13: cp cp1 -> reply {
+					action {
+						"PingPongPort.pongComplex(*transitionData);"
+					}
+				}
+				Transition tr14: cp cp1 -> reply {
+					cond {
+						"transitionData->i8ValPPD==7"
+					}
+					action {
+						"PingPongPort.pongComplex(*transitionData);"
+					}
+				}
+				Transition tr15: reply -> reply {
+					triggers {
+						<pingComplexDerived: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplexDerived(transitionData);"
+					}
+				}
+				Transition tr16: my tp0 -> my tp0 {
+					triggers {
+						<in1: extTest>
+					}
+				}
+				ChoicePoint cp0
+				ChoicePoint cp1
+				TransitionPoint tp0
+				State reply
+			}
+		}
+	}
+
+	ActorClass MrPing {
+		Interface {
+			conjugated Port PingPongPort: PingPongProtocol
+		}
+		Structure {
+			external Port PingPongPort
+			Attribute i8Val: int8="5"
+			Attribute i16Val:int16="19"
+			Attribute i32Val: int32 = "4711"
+			Attribute i64Val: int64 = "11470815"
+			Attribute i32Array [ 10 ]: int32 = "{0,1,2,3,4,5,6,7,8,9}"
+			Attribute f32Val: float32="3.14f"
+			Attribute f64Val: float64="7.987654321"
+			Attribute data: PingPongData
+			Attribute dataD: PingPongDataDerived
+			Attribute counter:int32
+			Attribute caseId: int32
+			Attribute lang: languageIndicator
+			Attribute resultlist [ 23 ]: int16 = "{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23}"
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> tp0 of state0 {
+					action {
+						"caseId = etUnit_openAll(\"log/testlog\", \"SendingDataTestCpp\", \"org.eclipse.etrice.generator.common.tests.SendingDataTest\", \"SendingDataTest_case\");"
+						"EXPECT_ORDER_START(caseId,resultlist,23);"
+						"EXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 1);"
+						"/* send the default values */"
+						""
+						"PingPongPort.pingInt8(i8Val);"
+						"PingPongPort.pingInt16(i16Val);"
+						"PingPongPort.pingInt32(i32Val);"
+						"PingPongPort.pingInt64(i64Val);"
+						"PingPongPort.pingFloat32(f32Val);"
+						"PingPongPort.pingFloat64(f64Val);"
+						"PingPongPort.pingInt16Ref(&i16Val);"
+						"PingPongPort.pingInt32Ref(&i32Val);"
+						"i8Val++;"
+						"i16Val++;"
+						"i32Val++;"
+						"i64Val++;"
+						"f32Val+=10.1;"
+						"f64Val+=20.2;"
+						"PingPongPort.pingInt8(i8Val);"
+						"PingPongPort.pingInt16(i16Val);"
+						"PingPongPort.pingInt32(i32Val);"
+						"PingPongPort.pingInt64(i64Val);"
+						"PingPongPort.pingFloat32(f32Val);"
+						"PingPongPort.pingFloat64(f64Val);"
+						"PingPongPort.pingInt16Ref(&i16Val);"
+						"PingPongPort.pingInt32Ref(&i32Val);"
+					}
+				}
+				Transition tr0: tp1 of state0 -> tp0 of state1
+				Transition tr1: tp1 of state1 -> test_finished
+				State state0 {
+					subgraph {
+						Transition tr0: my tp0 -> receiveFirst7 {
+							action {
+								"counter=0;"
+							}
+						}
+						Transition tr1: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt8: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==5){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 2);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr2: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt16: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==19){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 3);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr3: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==4711){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 4);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr4: receiveFirst7 -> receiveSecond7 {
+							triggers {
+								<pongInt32: PingPongPort guard {
+									"counter==7"
+								}>
+							}
+							action {
+								"counter=0;"
+								"if (lang == 1){"
+								"/* Java cannot send references of primitive types */"
+								"\tif (transitionData==4711){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 9);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"} "
+								"if (lang == 2){"
+								"/* C */"
+								"\tif (transitionData==4712){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 9);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"}"
+							}
+						}
+						Transition tr6: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==11470815){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 5);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr5: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongFloat32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>3)&&(transitionData<4)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 6);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr7: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongFloat64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>7)&&(transitionData<8)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 7);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr8: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt8: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==6){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 10);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr9: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt16: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==20){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 11);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr10: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==4712){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 12);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr11: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==11470816){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 13);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr12: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongFloat32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>13)&&(transitionData<14)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 14);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr13: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongFloat64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>28)&&(transitionData<29)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 15);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr14: receiveSecond7 -> my tp1 {
+							triggers {
+								<pongInt32: PingPongPort guard {
+									"counter==7"
+								}>
+							}
+							action {
+								"if (transitionData==4712){\t"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 17);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr15: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt16: PingPongPort guard {
+									"counter==6"
+								}>
+							}
+							action {
+								"counter++;"
+								"if (lang == 1){"
+								"/* Java cannot send references of primitive types */"
+								"\tif (transitionData==19){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 8);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"} "
+								"if (lang == 2){"
+								"/* C */"
+								"\tif (transitionData==20){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 8);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"}"
+							}
+						}
+						Transition tr16: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt16: PingPongPort guard {
+									"counter==6"
+								}>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==20){\t"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 16);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						EntryPoint tp0
+						ExitPoint tp1
+						State receiveFirst7
+						State receiveSecond7
+					}
+				}
+				State test_finished {
+					entry {
+						"EXPECT_ORDER_END(caseId,\"<|MODEL_LOCATION|>\", 23);"
+						"etUnit_closeAll(caseId);"
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State state1 {
+					subgraph {
+						Transition tr0: my tp0 -> state0 {
+							action {
+								"counter=0;"
+								"/* send default values */"
+								"PingPongPort.pingComplex(data);"
+								"PingPongPort.pingComplexRef(&data);"
+							}
+						}
+						Transition tr1: state0 -> state1 {
+							triggers {
+								<pongComplex: PingPongPort guard {
+									"counter==1"
+								}>
+							}
+							action {
+								"counter=0;"
+								"if (transitionData.i8ValPPD==10){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 19);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"if (transitionData.complexVal.i32Val2PPDD==80){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 20);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"dataD.i8ValPPD=11;"
+								"PingPongPort.pingComplexDerived(dataD);"
+							}
+						}
+						Transition tr2: state0 -> state0 {
+							triggers {
+								<pongComplex: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData.i8ValPPD==10){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 18);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr3: state1 -> my tp1 {
+							triggers {
+								<pongComplexDerived: PingPongPort>
+							}
+							action {
+								"if (transitionData.i8ValPPD==11){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 21);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"if (transitionData.i32Val3PPDe==150){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 22);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						EntryPoint tp0
+						ExitPoint tp1
+						State state0
+						State state1
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PingPongProtocol {
+		incoming {
+			Message pingInt8(d: int8)
+			Message pingInt16(d: int16)
+			Message pingInt32(d: int32)
+			Message pingInt64(d: int64)
+			Message pingFloat32(d: float32)
+			Message pingFloat64(d: float64)
+			Message pingInt16Ref(d: int16 ref)
+			Message pingInt32Ref(d: int32 ref)
+			Message pingComplex(d: PingPongData)
+			Message pingComplexRef(d: PingPongData ref)
+			Message pingComplexDerived(d:PingPongDataDerived)
+		}
+		outgoing {
+			Message pongInt8(d: int8)
+			Message pongInt16(d: int16)
+			Message pongInt32(d: int32)
+			Message pongInt64(d:int64)
+			Message pongFloat32(d: float32)
+			Message pongFloat64(d: float64)
+			Message pongComplex(d: PingPongData)
+			Message pongComplexDerived(d: PingPongDataDerived)
+		}
+	}
+
+	ProtocolClass PCExternal {
+		usercode1 {
+			"typedef int extMsg;"
+		}
+		incoming {
+			Message in1(can: DExtMsg)
+		}
+	}
+
+	DataClass PingPongData {
+		Attribute i8ValPPD: int8 = "10"
+		Attribute i8ValRefPPD: int8 ref
+		Attribute i32ArrayPPD [ 3 ]: int32 = "{200,300,400}"
+		Attribute i8ArrayRefPPD [ 2 ]: int8 ref
+		Attribute complexVal: PingPongDataDeep
+	}
+
+	DataClass PingPongDataDeep {
+		Attribute i32Val1PPDD: int32
+		Attribute i32Val2PPDD: int32 = "80"
+	}
+
+	DataClass PingPongDataDerived extends PingPongData {
+		Attribute i32Val3PPDe: int32 = "150"
+	}
+
+	ExternalType DExtMsg -> "extMsg"
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestJava.room b/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestJava.room
new file mode 100644
index 000000000..e71238b9b
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.common.tests/models/sendingData/SendingDataTestJava.room
@@ -0,0 +1,586 @@
+RoomModel SendingDataTestJava {
+
+	import room.basic.etunit.* from "../Tests.room"
+	import room.basic.types.* from "../Types.room"
+	import room.basic.language.* from "../Language.room"
+
+	ActorClass SendingDataTop {
+		@TestInstance
+		Structure {
+			ActorRef mrPing: MrPing
+			ActorRef mrPong: MrPong
+			Binding mrPong.PingPongPort and mrPing.PingPongPort
+		}
+		Behavior { }
+	}
+
+	ActorClass MrPong {
+		Interface {
+			Port PingPongPort: PingPongProtocol
+		}
+		Structure {
+			external Port PingPongPort
+		}
+		Behavior {
+			StateMachine {
+				Transition tr0: reply -> reply {
+					triggers {
+						<pingInt16: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt16(transitionData);"
+					}
+				}
+				Transition tr1: reply -> reply {
+					triggers {
+						<pingInt8: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt8(transitionData);"
+					}
+				}
+				Transition init: initial -> reply { }
+				Transition tr2: reply -> reply {
+					triggers {
+						<pingInt32: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt32(transitionData);"
+					}
+				}
+				Transition tr3: reply -> reply {
+					triggers {
+						<pingFloat32: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongFloat32(transitionData);"
+					}
+				}
+				Transition tr4: reply -> reply {
+					triggers {
+						<pingFloat64: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongFloat64(transitionData);"
+					}
+				}
+				Transition tr7: reply -> cp cp0 {
+					triggers {
+						<pingInt32Ref: PingPongPort guard {
+							"transitionData!=0"
+						}>
+					}
+				}
+				Transition tr8: cp cp0 -> reply {
+					action {
+						"PingPongPort.pongInt32(transitionData+10);"
+					}
+				}
+				Transition tr6: cp cp0 -> reply {
+					cond {
+						"transitionData!=5"
+					}
+					action {
+						"PingPongPort.pongInt32(transitionData);"
+					}
+				}
+				Transition tr9: reply -> reply {
+					triggers {
+						<pingComplex: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr11: reply -> reply {
+					triggers {
+						<pingComplexRef: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr5: reply -> reply {
+					triggers {
+						<pingInt64: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt64(transitionData);"
+					}
+				}
+				Transition tr10: reply -> reply {
+					triggers {
+						<pingInt16Ref: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongInt16(transitionData);"
+					}
+				}
+				Transition tr12: reply -> cp cp1 {
+					triggers {
+						<pingComplexRef: PingPongPort guard {
+							"transitionData.i8Val == 5"
+						}>
+					}
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr13: cp cp1 -> reply {
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr14: cp cp1 -> reply {
+					cond {
+						"transitionData.i8Val==7"
+					}
+					action {
+						"PingPongPort.pongComplex(transitionData);"
+					}
+				}
+				Transition tr15: reply -> reply {
+					triggers {
+						<pingComplexDerived: PingPongPort>
+					}
+					action {
+						"PingPongPort.pongComplexDerived(transitionData);"
+					}
+				}
+				ChoicePoint cp0
+				ChoicePoint cp1
+				State reply
+			}
+		}
+	}
+
+	ActorClass MrPing {
+		Interface {
+			conjugated Port PingPongPort: PingPongProtocol
+		}
+		Structure {
+			external Port PingPongPort
+			Attribute i8Val: int8="5"
+			Attribute i16Val:int16="19"
+			Attribute i32Val: int32 = "4711"
+			Attribute i64Val: int64 = "11470815"
+			Attribute i32Array [ 10 ]: int32="{0,1,2,3,4,5,6,7,8,9}"
+			Attribute f32Val: float32="3.14"
+			Attribute f64Val: float64="7.987654321"
+			Attribute data: PingPongData
+			Attribute dataD: PingPongDataDerived
+			Attribute counter:int32
+			Attribute caseId: int32
+			Attribute lang: languageIndicator
+			Attribute resultlist [ 18 ]: int16 = "{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23}"
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> tp0 of state0 {
+					action {
+						"caseId = etUnit_openAll(\"log/testlog\", \"SendingDataTestJava\", \"org.eclipse.etrice.generator.common.tests.SendingDataTest\", \"SendingDataTest_case\");"
+						"EXPECT_ORDER_START(caseId,resultlist,23);"
+						"EXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 1);"
+						"// send the default values"
+						""
+						"PingPongPort.pingInt8(i8Val);"
+						"PingPongPort.pingInt16(i16Val);"
+						"PingPongPort.pingInt32(i32Val);"
+						"PingPongPort.pingInt64(i64Val);"
+						"PingPongPort.pingFloat32(f32Val);"
+						"PingPongPort.pingFloat64(f64Val);"
+						"PingPongPort.pingInt16Ref(i16Val);"
+						"PingPongPort.pingInt32Ref(i32Val);"
+						"i8Val++;"
+						"i16Val++;"
+						"i32Val++;"
+						"i64Val++;"
+						"f32Val+=10.1;"
+						"f64Val+=20.2;"
+						"PingPongPort.pingInt8(i8Val);"
+						"PingPongPort.pingInt16(i16Val);"
+						"PingPongPort.pingInt32(i32Val);"
+						"PingPongPort.pingInt64(i64Val);"
+						"PingPongPort.pingFloat32(f32Val);"
+						"PingPongPort.pingFloat64(f64Val);"
+						"PingPongPort.pingInt16Ref(i16Val);"
+						"PingPongPort.pingInt32Ref(i32Val);"
+					}
+				}
+				Transition tr0: tp1 of state0 -> tp0 of state1
+				Transition tr1: tp1 of state1 -> test_finished
+				State state0 {
+					subgraph {
+						Transition tr0: my tp0 -> receiveFirst7 {
+							action {
+								"counter=0;"
+							}
+						}
+						Transition tr1: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt8: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==5){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 2);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr2: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt16: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==19){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 3);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr3: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==4711){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 4);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}						
+						Transition tr4: receiveFirst7 -> receiveSecond7 {
+							triggers {
+								<pongInt32: PingPongPort guard {
+									"counter==7"
+								}>
+							}
+							action {
+								"counter=0;"
+								"if (lang == 1){"
+								"// Java cannot send references of primitive types"
+								"\tif (transitionData==4711){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 9);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"} "
+								"if (lang == 2){"
+								"// C"
+								"\tif (transitionData==4712){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 9);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"}"
+							}
+						}
+						Transition tr6: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==11470815){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 5);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr5: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongFloat32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>3)&&(transitionData<4)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 6);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr7: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongFloat64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>7)&&(transitionData<8)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 7);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr8: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt8: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==6){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 10);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr9: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt16: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==20){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 11);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr10: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==4712){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 12);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr11: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==11470816){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 13);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr12: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongFloat32: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>13)&&(transitionData<14)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 14);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr13: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongFloat64: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if ((transitionData>28)&&(transitionData<29)){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 15);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr14: receiveSecond7 -> my tp1 {
+							triggers {
+								<pongInt32: PingPongPort guard {
+									"counter==7"
+								}>
+							}
+							action {
+								"if (transitionData==4712){\t"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 17);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr15: receiveFirst7 -> receiveFirst7 {
+							triggers {
+								<pongInt16: PingPongPort guard {
+									"counter==6"
+								}>
+							}
+							action {
+								"counter++;"
+								"if (lang == 1){"
+								"// Java cannot send references of primitive types"
+								"\tif (transitionData==19){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 8);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"} "
+								"if (lang == 2){"
+								"// C"
+								"\tif (transitionData==20){\t"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 8);"
+								"\t}else{"
+								"\t\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"\t}"
+								"}"
+							}
+						}
+						Transition tr16: receiveSecond7 -> receiveSecond7 {
+							triggers {
+								<pongInt16: PingPongPort guard {
+									"counter==6"
+								}>
+							}
+							action {
+								"counter++;"
+								"if (transitionData==20){\t"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 16);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						EntryPoint tp0
+						ExitPoint tp1
+						State receiveFirst7
+						State receiveSecond7
+					}
+				}
+				State test_finished {
+					entry {
+						"EXPECT_ORDER_END(caseId,\"<|MODEL_LOCATION|>\", 23);"
+						"etUnit_closeAll(caseId);"
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State state1 {
+					subgraph {
+						Transition tr0: my tp0 -> state0 {
+							action {
+								"counter=0;"
+								"// send default values"
+								"PingPongPort.pingComplex(data);"
+								"PingPongPort.pingComplexRef(data);"
+							}
+						}
+						Transition tr1: state0 -> state1 {
+							triggers {
+								<pongComplex: PingPongPort guard {
+									"counter==1"
+								}>
+							}
+							action {
+								"counter=0;"
+								"if (transitionData.i8Val==10){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 19);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"if (transitionData.complexVal.i32Val2==80){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 20);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"dataD.i8Val=11;"
+								"PingPongPort.pingComplexDerived(dataD);"
+							}
+						}
+						Transition tr2: state0 -> state0 {
+							triggers {
+								<pongComplex: PingPongPort>
+							}
+							action {
+								"counter++;"
+								"if (transitionData.i8Val==10){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 18);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						Transition tr3: state1 -> my tp1 {
+							triggers {
+								<pongComplexDerived: PingPongPort>
+							}
+							action {
+								"if (transitionData.i8Val==11){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 21);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+								""
+								"if (transitionData.i32Val3==150){"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 22);"
+								"}else{"
+								"\tEXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+								"}"
+							}
+						}
+						EntryPoint tp0
+						ExitPoint tp1
+						State state0
+						State state1
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PingPongProtocol {
+		incoming {
+			Message pingInt8(d: int8)
+			Message pingInt16(d: int16)
+			Message pingInt32(d: int32)
+			Message pingInt64(d: int64)
+			Message pingFloat32(d: float32)
+			Message pingFloat64(d: float64)
+			Message pingInt16Ref(d: int16 ref)
+			Message pingInt32Ref(d: int32 ref)
+			Message pingComplex(d: PingPongData)
+			Message pingComplexRef(d: PingPongData ref)
+			Message pingComplexDerived(d:PingPongDataDerived)
+		}
+		outgoing {
+			Message pongInt8(d: int8)
+			Message pongInt16(d: int16)
+			Message pongInt32(d: int32)
+			Message pongInt64(d:int64)
+			Message pongFloat32(d: float32)
+			Message pongFloat64(d: float64)
+			Message pongComplex(d: PingPongData)
+			Message pongComplexDerived(d: PingPongDataDerived)
+		}
+	}
+
+	DataClass PingPongData {
+		Attribute i8Val: int8 = "10"
+		Attribute i8ValRef: int8 ref
+		Attribute i32Array [ 3 ]: int32 = "{200,300,400}"
+		Attribute i8ArrayRef [ 2 ]: int8 ref
+		Attribute complexVal: PingPongDataDeep
+	}
+
+	DataClass PingPongDataDeep {
+		Attribute i32Val1: int32
+		Attribute i32Val2: int32 = "80"
+	}
+
+	DataClass PingPongDataDerived extends PingPongData {
+		Attribute i32Val3: int32 = "150"
+	}
+}
diff --git a/tests/org.eclipse.etrice.generator.cpp.tests/.gitignore b/tests/org.eclipse.etrice.generator.cpp.tests/.gitignore
index b45c5f774..57f15dea9 100644
--- a/tests/org.eclipse.etrice.generator.cpp.tests/.gitignore
+++ b/tests/org.eclipse.etrice.generator.cpp.tests/.gitignore
@@ -1 +1,7 @@
-src-gen/
\ No newline at end of file
+src-gen/
+bin
+models
+output
+results
+src-gen
+log
diff --git a/tests/org.eclipse.etrice.generator.cpp.tests/org.eclipse.etrice.generator.cpp.tests make.xml.launch b/tests/org.eclipse.etrice.generator.cpp.tests/org.eclipse.etrice.generator.cpp.tests make.xml.launch
new file mode 100644
index 000000000..dd7cac532
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.cpp.tests/org.eclipse.etrice.generator.cpp.tests make.xml.launch
@@ -0,0 +1,38 @@
+
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.ant.AntLaunchConfigurationType">
+<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.etrice.generator.cpp.tests/make.xml"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.cpp.tests"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<mapAttribute key="org.eclipse.ui.externaltools.ATTR_ANT_PROPERTIES">
+<mapEntry key="com.google.guava" value="${target_platform_plugin_location:com.google.guava}"/>
+<mapEntry key="com.google.inject" value="${target_platform_plugin_location:com.google.inject}"/>
+<mapEntry key="eclipse.home" value="${eclipse_home}"/>
+<mapEntry key="eclipse.pdebuild.home" value="${target_platform_plugin_location:org.eclipse.pde.build}"/>
+<mapEntry key="eclipse.pdebuild.scripts" value="${target_platform_plugin_location:org.eclipse.pde.build}/scripts/"/>
+<mapEntry key="eclipse.pdebuild.templates" value="${target_platform_plugin_location:org.eclipse.pde.build}/templates/"/>
+<mapEntry key="eclipse.running" value="true"/>
+<mapEntry key="javax.inject" value="${target_platform_plugin_location:javax.inject}"/>
+<mapEntry key="org.antlr.runtime" value="${target_platform_plugin_location:org.antlr.runtime}"/>
+<mapEntry key="org.apache.log4j" value="${target_platform_plugin_location:org.apache.log4j}"/>
+<mapEntry key="org.eclipse.emf.common" value="${target_platform_plugin_location:org.eclipse.emf.common}"/>
+<mapEntry key="org.eclipse.emf.ecore" value="${target_platform_plugin_location:org.eclipse.emf.ecore}"/>
+<mapEntry key="org.eclipse.emf.ecore.xmi" value="${target_platform_plugin_location:org.eclipse.emf.ecore.xmi}"/>
+<mapEntry key="org.eclipse.equinox.common" value="${target_platform_plugin_location:org.eclipse.equinox.common}"/>
+<mapEntry key="org.eclipse.xtend.lib" value="${target_platform_plugin_location:org.eclipse.xtend.lib}"/>
+<mapEntry key="org.eclipse.xtext" value="${target_platform_plugin_location:org.eclipse.xtext}"/>
+<mapEntry key="org.eclipse.xtext.common.types" value="${target_platform_plugin_location:org.eclipse.xtext.common.types}"/>
+<mapEntry key="org.eclipse.xtext.util" value="${target_platform_plugin_location:org.eclipse.xtext.util}"/>
+<mapEntry key="org.eclipse.xtext.xbase.lib" value="${target_platform_plugin_location:org.eclipse.xtext.xbase.lib}"/>
+</mapAttribute>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_ANT_TARGETS" value="clean,all,"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/org.eclipse.etrice.generator.cpp.tests/make.xml}"/>
+<stringAttribute key="process_factory_id" value="org.eclipse.ant.ui.remoteAntProcessFactory"/>
+</launchConfiguration>
diff --git a/tests/org.eclipse.etrice.generator.fsmtest.tests/org.eclipse.etrice.generator.fsmtest.tests.launch b/tests/org.eclipse.etrice.generator.fsmtest.tests/org.eclipse.etrice.generator.fsmtest.tests.launch
index d0e2dcf62..0fb1006df 100644
--- a/tests/org.eclipse.etrice.generator.fsmtest.tests/org.eclipse.etrice.generator.fsmtest.tests.launch
+++ b/tests/org.eclipse.etrice.generator.fsmtest.tests/org.eclipse.etrice.generator.fsmtest.tests.launch
@@ -10,6 +10,7 @@
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
 <stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.fsmtest.tests"/>
 <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
diff --git a/tests/org.eclipse.etrice.generator.java.tests/.gitignore b/tests/org.eclipse.etrice.generator.java.tests/.gitignore
index b45c5f774..04ab4331e 100644
--- a/tests/org.eclipse.etrice.generator.java.tests/.gitignore
+++ b/tests/org.eclipse.etrice.generator.java.tests/.gitignore
@@ -1 +1,10 @@
-src-gen/
\ No newline at end of file
+src-gen/
+bin
+models
+output
+results
+src-gen
+log
+/tmp/
+/firstOpt.obj
+/secondOpt.obj
diff --git a/tests/org.eclipse.etrice.generator.java.tests/make.xml b/tests/org.eclipse.etrice.generator.java.tests/make.xml
new file mode 100644
index 000000000..bb84b48e3
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/make.xml
@@ -0,0 +1,130 @@
+
+<?xml version="1.0"?>
+<!--
+	Ant makefile for building and running of tests.
+	
+	Includes common.xml from org.eclipse.etrice.generator.common.tests
+-->
+<project name="org.eclipse.etrice.generator.java.tests" basedir="." default="all">
+	
+	<target name="testing" depends="dynamicActorTests,common.testing">
+		
+		<!-- add test here, testid==testSuiteFileName -->
+		<test testid="TCPTest"		 	 	models="${models.path}/TCPTest.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DynamicConfigTest" 	models="${models.path}/DynamicConfigTest.etmap ${models.path}/DynamicConfigTest.config"/>
+		<test testid="StaticConfigTest" models="${models.path}/staticConfig/StaticConfigTest.etmap ${models.path}/staticConfig/StaticConfigTest.config" />
+		<test testid="SendingDataTestJava" 	models="${models.path}/sendingData/SendingDataTestJava.room ${models.path}/GenericPhysical.etphys" />
+		
+		<echo>done with ${ant.project.name}</echo>
+	</target>
+	
+	<target name="dynamicActorTests">
+		<property name="genOptions" value="-persistable -storeDataObj"/>
+		
+		<test testid="DynamicActorTest1" genOptions="${genOptions}" models="${models.path}/DynamicActorTest1.etmap" />
+		<test testid="DynamicActorTest2" genOptions="${genOptions}" models="${models.path}/DynamicActorTest2.etmap" />
+		<test testid="DynamicActorTest3" genOptions="${genOptions}" models="${models.path}/DynamicActorTest3.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DynamicActorTest4" genOptions="${genOptions}" models="${models.path}/DynamicActorTest4.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DynamicActorTest5" genOptions="${genOptions}" models="${models.path}/DynamicActorTest5.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DynamicActorTest6" genOptions="${genOptions}" models="${models.path}/DynamicActorTest6.room ${models.path}/GenericPhysical.etphys" />
+		<test testid="DynamicActorTest7" genOptions="${genOptions}" models="${models.path}/DynamicActorTest7.etmap" />
+		<test testid="StoreRestore" 	 genOptions="${genOptions}" models="${models.path}/StoreRestore.room ${models.path}/GenericPhysical.etphys" />
+	</target>
+	
+	<target name="copyModels" depends="common.copyModels">
+		<copy todir="${models.path}">
+			<fileset dir="./targetModels"/>
+		</copy>
+		<move file="${models.path}/staticConfig/StaticConfigTest_Java.room" toFile="${models.path}/staticConfig//StaticConfigTest.room" />
+	</target>
+	
+	<!-- ################################################################ -->
+	
+	<import file="../org.eclipse.etrice.generator.common.tests/common.xml" as="common"/>
+	
+	<property name="modellib.path" value="../../runtime/org.eclipse.etrice.modellib.java" />
+	<property name="runtime.path" value="../../runtime/org.eclipse.etrice.runtime.java" />
+	
+	<target name="all" depends="clean,copyModels,testing"/>
+		
+	<!-- test := generate 1 executable, build, run, process results -->
+	<macrodef name="test">
+		<attribute name="testId"/>
+		<attribute name="models"/>
+		<attribute name="genOptions" default=""/>
+		<sequential>
+			<standaloneGenerator testId="@{testId}" models="@{models}" genOptions="@{genOptions}"/>
+			<build testId="@{testId}"/>
+			<run testId="@{testId}"/>
+			<convert testId="@{testId}"/>
+			<copyResult testId="@{testId}" targetId="Java_"/>
+		</sequential>
+	</macrodef>
+	
+	<macrodef name="standaloneGenerator">
+		<attribute name="testId"/>
+		<attribute name="models"/>
+		<attribute name="genOptions" default=""/>
+		<sequential>
+			<mkdir dir="${output}"/>
+			<java output="${output}/generate.txt" error="${output}/generate_err.txt" classname="org.eclipse.etrice.generator.java.Main" fork="true" failonerror="true">
+				<arg line="@{models}"/>
+				<arg value="-genDir"/><arg value="src-gen/@{testId}"/>
+				<arg value="-msc_instr" />
+				<arg line="@{genOptions}" />
+				<classpath refid="etrice.clspath" />
+			</java>
+		</sequential>
+	</macrodef>
+	
+		<!--
+			compile: compiles the generated Java sources
+		-->
+		<macrodef name="build">
+			<attribute name="testId"/>
+			<sequential>
+				<mkdir dir="${bin.path}/@{testId}" />
+				<!-- ./src/xxx is optional, create it anyway to avoid error -->
+				<mkdir dir="./src/@{testId}" />
+				<record name="${basedir}/output/compile.txt" action="start"/>
+				<javac destdir="${bin.path}/@{testId}" source="1.6" classpath="${runtime.path}/target/classes" debug="off" verbose="off">
+					<src>
+						<pathelement location="src-gen/@{testId}" />
+						<pathelement location="src/@{testId}" />
+					</src>
+				</javac>
+				<record name="${basedir}/output/compile.txt" action="stop"/>
+			</sequential>
+		</macrodef>
+
+		<!--
+			run: runs all executables
+		-->
+		<macrodef name="run">
+			<attribute name="testId"/>
+			<sequential>
+				<mkdir dir="${testlog.path}" />
+				<!-- get runner class -->
+				<local name="runner.class"/>
+			 	<fileset id="runnerFileSet" dir="./src-gen/@{testId}">
+					<include name="**/*Runner.java"/>
+				</fileset>
+				<pathconvert property="runner.class">
+					<string>${toString:runnerFileSet}</string>
+					<chainedmapper>
+						<globmapper from="*.java" to="*"/>
+						<packagemapper from="*" to="*"/>
+					</chainedmapper>
+				</pathconvert>
+				<!--<echo>path of runner.java: ${toString:runnerFileSet}</echo>
+				<echo>runner path converted to class: ${runner.class}</echo>-->
+				
+				<echo>run @{testId}</echo>
+				<java output="${output}/run@{testId}.txt" classname="${runner.class}" fork="true" failonerror="true" timeout="${run.msTimout}">
+					<arg value="-run_as_test" />
+					<classpath path="./bin/@{testId};${runtime.path}/target/classes;" />
+				</java>
+			</sequential>
+		</macrodef>
+
+</project>
diff --git a/tests/org.eclipse.etrice.generator.java.tests/org.eclipse.etrice.generator.java.tests make.xml.launch b/tests/org.eclipse.etrice.generator.java.tests/org.eclipse.etrice.generator.java.tests make.xml.launch
new file mode 100644
index 000000000..b6e1066d7
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/org.eclipse.etrice.generator.java.tests make.xml.launch
@@ -0,0 +1,44 @@
+
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.ant.AntLaunchConfigurationType">
+<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${project}"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.etrice.generator.java.tests/make.xml"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
+<listEntry value="org.eclipse.ui.externaltools.launchGroup"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.generator.java.tests"/>
+<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
+<mapAttribute key="org.eclipse.ui.externaltools.ATTR_ANT_PROPERTIES">
+<mapEntry key="com.google.guava" value="${target_platform_plugin_location:com.google.guava}"/>
+<mapEntry key="com.google.inject" value="${target_platform_plugin_location:com.google.inject}"/>
+<mapEntry key="eclipse.home" value="${eclipse_home}"/>
+<mapEntry key="eclipse.pdebuild.home" value="${target_platform_plugin_location:org.eclipse.pde.build}"/>
+<mapEntry key="eclipse.pdebuild.scripts" value="${target_platform_plugin_location:org.eclipse.pde.build}/scripts/"/>
+<mapEntry key="eclipse.pdebuild.templates" value="${target_platform_plugin_location:org.eclipse.pde.build}/templates/"/>
+<mapEntry key="eclipse.running" value="true"/>
+<mapEntry key="javax.inject" value="${target_platform_plugin_location:javax.inject}"/>
+<mapEntry key="org.antlr.runtime" value="${target_platform_plugin_location:org.antlr.runtime}"/>
+<mapEntry key="org.apache.log4j" value="${target_platform_plugin_location:org.apache.log4j}"/>
+<mapEntry key="org.eclipse.emf.common" value="${target_platform_plugin_location:org.eclipse.emf.common}"/>
+<mapEntry key="org.eclipse.emf.ecore" value="${target_platform_plugin_location:org.eclipse.emf.ecore}"/>
+<mapEntry key="org.eclipse.emf.ecore.xmi" value="${target_platform_plugin_location:org.eclipse.emf.ecore.xmi}"/>
+<mapEntry key="org.eclipse.equinox.common" value="${target_platform_plugin_location:org.eclipse.equinox.common}"/>
+<mapEntry key="org.eclipse.xtend.lib" value="${target_platform_plugin_location:org.eclipse.xtend.lib}"/>
+<mapEntry key="org.eclipse.xtext" value="${target_platform_plugin_location:org.eclipse.xtext}"/>
+<mapEntry key="org.eclipse.xtext.common.types" value="${target_platform_plugin_location:org.eclipse.xtext.common.types}"/>
+<mapEntry key="org.eclipse.xtext.util" value="${target_platform_plugin_location:org.eclipse.xtext.util}"/>
+<mapEntry key="org.eclipse.xtext.xbase.lib" value="${target_platform_plugin_location:org.eclipse.xtext.xbase.lib}"/>
+</mapAttribute>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_ANT_TARGETS" value="clean,all,"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LAUNCH_CONFIGURATION_BUILD_SCOPE" value="${none}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/org.eclipse.etrice.generator.java.tests/make.xml}"/>
+<stringAttribute key="org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS" value="-v"/>
+<stringAttribute key="process_factory_id" value="org.eclipse.ant.ui.remoteAntProcessFactory"/>
+</launchConfiguration>
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest1.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest1.room
new file mode 100644
index 000000000..eef0c5cdc
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest1.room
@@ -0,0 +1,182 @@
+RoomModel DynamicActorTest1 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	LogicalSystem JavaGenTests {
+		SubSystemRef da1Test : SubSystem_DynamicActorTest1
+	}
+	
+	SubSystemClass SubSystem_DynamicActorTest1 {
+		ActorRef appl : Appl
+	
+		LogicalThread defaultThread
+	}
+	
+	ActorClass Appl {
+		Structure {
+			ActorRef cont: Container
+		}
+		Behavior { }
+	}
+	
+	ActorClass Container {
+		Structure {
+			conjugated Port p0: PC
+			Attribute caseId: int32
+			optional ActorRef opt: Optional
+			
+			Binding p0 and opt.p0
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest1\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest1\", \"DynamicActorTest1_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			
+			StateMachine {
+				Transition init: initial -> CreateOptional2 { }
+				Transition tr0: CreateOptional2 -> CreateOptional1 {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC3:/JavaGenTests/da1Test/appl/cont/opt/sub2/deep_sub\"));"
+						"opt.destroyOptionalActor();"
+					}
+				}
+				Transition tr2: CreateOptional1 -> ReceivedHelloAgain {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC1:/JavaGenTests/da1Test/appl/cont/opt/sub1\"));"
+						"opt.destroyOptionalActor();"
+					}
+				}
+				State CreateOptional2 {
+					entry {
+						"opt.createOptionalActor(\"Optional2\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State CreateOptional1 {
+					entry {
+						"opt.createOptionalActor(\"Optional1\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State ReceivedHelloAgain {
+					entry {
+						"IRTObject opt = getChild(\"opt\");"
+						"int size = opt.getChildren().size();"
+						""
+						"// we expect the RTSystemPort and the InterfaceItemBroker"
+						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, size);"
+						""
+						"etUnit_testFinished(caseId);"
+					}
+				}
+			}
+		}
+	}
+	
+	// the class that is referenced as optional by the Container
+	// since it is abstract it just serves as an interface
+	abstract ActorClass Optional {
+		Interface {
+			Port p0: PC
+		}
+		Structure { }
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional1 extends Optional {
+		Structure {
+			ActorRef sub1: AC1
+			Binding p0 and sub1.p0
+		}
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional2 extends Optional {
+		Structure {
+			ActorRef sub2: AC2
+			Binding p0 and sub2.p0
+		}
+		Behavior { }
+	}
+	
+	// the following actor classes are part of the possible optional instance sub trees
+	
+	ActorClass AC1 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"AC1:\"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	ActorClass AC2 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef deep_sub: AC3
+			Binding p0 and deep_sub.p0
+		}
+		Behavior { }
+	}
+	
+	ActorClass AC3 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"AC3:\"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	// a simple protocol that is used to demonstrate that actors are connected
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest2.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest2.room
new file mode 100644
index 000000000..5e646ac99
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest2.room
@@ -0,0 +1,236 @@
+RoomModel DynamicActorTest2 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	LogicalSystem JavaGenTests {
+		SubSystemRef da2Test : SubSystem_DynamicActorTest2
+	}
+	
+	SubSystemClass SubSystem_DynamicActorTest2 {
+		ActorRef appl : Appl
+	
+		LogicalThread defaultThread
+	}
+	
+	ActorClass Appl {
+		Structure {
+			ActorRef cont: Container
+		}
+		Behavior { }
+	}
+	
+	ActorClass Container {
+		Structure {
+			conjugated Port p0[*]: PC
+			Attribute caseId: int32
+			optional ActorRef optarray[*]: Optional
+			
+			Binding p0 and optarray.p0
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest2\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest2\", \"DynamicActorTest2_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+
+			StateMachine {
+				Transition init: initial -> CreateOptional2 { }
+				Transition tr0: CreateOptional2 -> CreateOptional1 {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC3:/JavaGenTests/da2Test/appl/cont/optarray:0/sub2/deep_sub\"));"
+					}
+				}
+				Transition tr2: CreateOptional1 -> ReceivedHelloAgain {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC3:/JavaGenTests/da2Test/appl/cont/optarray:0/sub2/deep_sub\"));"
+					}
+				}
+				Transition tr1: ReceivedHelloAgain -> Destroy0 {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC1:/JavaGenTests/da2Test/appl/cont/optarray:1/sub1\"));"
+					}
+				}
+				Transition tr3: Destroy0 -> Destroy1Create2 {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC1:/JavaGenTests/da2Test/appl/cont/optarray:1/sub1\"));"
+					}
+				}
+				Transition tr4: Destroy1Create2 -> Done {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"EXPECT_TRUE(caseId, \"<|MODEL_LOCATION|>\", transitionData.equals(\"AC3:/JavaGenTests/da2Test/appl/cont/optarray:1/sub2/deep_sub\"));"
+					}
+				}
+				State CreateOptional2 {
+					entry {
+						"optarray.createOptionalActor(\"Optional2\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State CreateOptional1 {
+					entry {
+						"optarray.createOptionalActor(\"Optional1\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State ReceivedHelloAgain
+				State Destroy0 {
+					entry {
+						"optarray.destroyOptionalActor(0);"
+						"p0.sayHello();"
+					}
+				}
+				State Destroy1Create2 {
+					entry {
+						"optarray.destroyOptionalActor(1);"
+						""
+						"IRTObject opt = getChild(\"optarray\");"
+						"int size = opt.getChildren().size();"
+						""
+						"// we expect the RTSystemPort and the InterfaceItemBroker"
+						"EXPECT_EQUAL_INT32(caseId, \"<|MODEL_LOCATION|>\", 2, size);"
+						""
+						"optarray.createOptionalActor(\"Optional2\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State Done {
+					entry {
+						"IRTObject opt = getChild(\"optarray\");"
+						"int size = opt.getChildren().size();"
+						""
+						"// we expect the RTSystemPort and the InterfaceItemBroker"
+						"// plus an instance of Optional2"
+						"// plus 3 sub ports of RTSystemPort"
+						"EXPECT_EQUAL_INT32(caseId, \"<MODEL_LOCATION|>\", 6, size);"
+						""
+						"// we grab the leaf actor of the optional sub tree"
+						"IRTObject leafActor = getObject(\"/JavaGenTests/da2Test/appl/cont/optarray/optarray:1/sub2/deep_sub\");"
+						"size = leafActor.getChildren().size();"
+						""
+						"// we expect an RTSystemPort and p0"
+						"EXPECT_EQUAL_INT32(caseId, \"<MODEL_LOCATION|>\", 2, size);"
+						""
+						"EXPECT_TRUE(caseId, \"<MODEL_LOCATION|>\", leafActor.getInstancePath().equals(\"/JavaGenTests/da2Test/appl/cont/optarray:1/sub2/deep_sub\"));"
+						""
+						"etUnit_testFinished(caseId);"
+					}
+				}
+			}
+		}
+	}
+	
+	// the class that is referenced as optional by the Container
+	// since it is abstract it just serves as an interface
+	abstract ActorClass Optional {
+		Interface {
+			Port p0: PC
+		}
+		Structure { }
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional1 extends Optional {
+		Structure {
+			ActorRef sub1: AC1
+			Binding p0 and sub1.p0
+		}
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional2 extends Optional {
+		Structure {
+			ActorRef sub2: AC2
+			Binding p0 and sub2.p0
+		}
+		Behavior { }
+	}
+	
+	// the following actor classes are part of the possible optional instance sub trees
+	
+	ActorClass AC1 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"AC1:\"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	ActorClass AC2 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef deep_sub: AC3
+			Binding p0 and deep_sub.p0
+		}
+		Behavior { }
+	}
+	
+	ActorClass AC3 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"AC3:\"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	// a simple protocol that is used to demonstrate that actors are connected
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest3.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest3.room
new file mode 100644
index 000000000..c6244399a
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest3.room
@@ -0,0 +1,235 @@
+RoomModel DynamicActorTest3 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	ActorClass Appl {
+		@TestInstance
+		Structure {
+			ActorRef cont: Controller
+		}
+		Behavior { }
+	}
+	
+	ActorClass Controller {
+		Structure {
+			conjugated Port pwrk: PWorker
+			conjugated Port opt: PC
+			Attribute caseId: int32
+			ActorRef worker: Worker
+			Binding pwrk and worker.fct
+			Binding opt and worker.opt
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest3\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest3\", \"DynamicActorTest3_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			StateMachine {
+				Transition init: initial -> createOpt1 { }
+				Transition tr0: createOpt1 -> SendHello {
+					triggers {
+						<ok: pwrk>
+					}
+				}
+				Transition tr1: SendHello -> TryCreateInvalid {
+					triggers {
+						<hello: opt>
+					}
+					action {
+						"System.out.println(\"controller received \"+transitionData);"
+					}
+				}
+				Transition tr2: createOpt1 -> UnexpectedError {
+					triggers {
+						<error: pwrk>
+					}
+				}
+				Transition tr3: TryCreateInvalid -> ExpectedError {
+					triggers {
+						<error: pwrk>
+					}
+				}
+				State createOpt1 {
+					entry {
+						"pwrk.create(\"Optional1\");"
+					}
+				}
+				State SendHello {
+					entry {
+						"opt.sayHello();"
+					}
+				}
+				State TryCreateInvalid {
+					entry {
+						"pwrk.create(\"Optional\");"
+					}
+				}
+				State UnexpectedError
+				State ExpectedError {
+					entry {
+						"etUnit_testFinished(caseId);"
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass Worker {
+		Interface {
+			Port fct: PWorker
+			Port opt: PC
+		}
+		Structure {
+			external Port fct
+			optional ActorRef optRef: Optional
+			Binding opt and optRef.p0
+		}
+		Behavior {
+			// this method prints the passed message and then dumps the object tree consisting of actors and ports
+			Operation dumpTree(msg: string) {
+				"System.out.println(msg);"
+				"System.out.println(((org.eclipse.etrice.runtime.java.messaging.RTObject)getRoot()).toStringRecursive());"
+			}
+			
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<create: fct>
+					}
+					action {
+						"if (optRef.createOptionalActor(transitionData, getThread()))"
+						"\tfct.ok();"
+						"else"
+						"\tfct.error();"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	// the class that is referenced as optional by the Worker
+	// since it is abstract it just serves as an interface
+	abstract ActorClass Optional {
+		Interface {
+			Port p0: PC
+		}
+		Structure { }
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional1 extends Optional {
+		Structure {
+			ActorRef sub1: AC1
+			Binding p0 and sub1.p0
+		}
+		Behavior { }
+	}
+	
+	// a sub class of Optional which is valid as optional actor
+	ActorClass Optional2 extends Optional {
+		Structure {
+			ActorRef sub2: AC2
+			Binding p0 and sub2.p0
+		}
+		Behavior { }
+	}
+	
+	// the following actor classes are part of the possible optional instance sub trees
+	
+	ActorClass AC1 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+			conjugated Port hlp: PC
+			ActorRef helper: AC3
+			Binding hlp and helper.p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> AskHelper {
+					triggers {
+						<sayHello: p0>
+					}
+				}
+				Transition tr1: AskHelper -> Ready {
+					triggers {
+						<hello: hlp>
+					}
+					action {
+						"System.out.println(\"helper said \"+transitionData);"
+						"p0.hello(\"this is AC1, instance \"+getInstancePath());"
+					}
+				}
+				State Ready
+				State AskHelper {
+					entry {
+						"hlp.sayHello();"
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass AC2 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef deep_sub: AC3
+			Binding p0 and deep_sub.p0
+		}
+		Behavior { }
+	}
+	
+	ActorClass AC3 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"this is AC3, instance \"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	// a simple protocol that is used to demonstrate that actors are connected
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+	
+	ProtocolClass PWorker {
+		incoming {
+			Message create(ac: string)
+		}
+		outgoing {
+			Message ok()
+			Message error()
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest4.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest4.room
new file mode 100644
index 000000000..7affbda90
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest4.room
@@ -0,0 +1,97 @@
+RoomModel DynamicActorTest4 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	ActorClass Appl {
+		@TestInstance
+		Structure {
+			ActorRef cont: Container
+		}
+		Behavior { }
+	}
+	
+	ActorClass Container {
+		Structure {
+			conjugated Port p0: PC
+			Attribute caseId: int32
+			optional ActorRef opt: Optional
+			
+			Binding p0 and opt.p0
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest4\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest4\", \"DynamicActorTest4_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			
+			// this method prints the passed message and then dumps the object tree consisting of actors and ports
+			Operation dumpTree(msg: string) {
+				"System.out.println(msg);"
+				"System.out.println(((org.eclipse.etrice.runtime.java.messaging.RTObject)getRoot()).toStringRecursive());"
+			}
+			
+			StateMachine {
+				Transition init: initial -> CreateOptional { }
+				Transition tr0: CreateOptional -> Done {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"System.out.println(transitionData+\"\\n\");"
+						"opt.destroyOptionalActor();"
+						"dumpTree(\"after deletion of Optional2\");"
+					}
+				}
+				State CreateOptional {
+					entry {
+						"opt.createOptionalActor(\"Optional\", getThread());"
+						"p0.sayHello();"
+					}
+				}
+				State Done {
+					entry {
+						"etUnit_testFinished(caseId);"
+					}
+				}
+			}
+		}
+	}
+	
+	// the class that is referenced as optional by the Container
+	// It has an external end port and implements the behavior itself
+	ActorClass Optional {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: p0>
+					}
+					action {
+						"p0.hello(\"this is AC1, instance \"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	// a simple protocol that is used to demonstrate that actors are connected
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest5.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest5.room
new file mode 100644
index 000000000..795306dc0
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest5.room
@@ -0,0 +1,149 @@
+RoomModel DynamicActorTest5 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	ActorClass Appl {
+		@TestInstance
+		Structure {
+			ActorRef cont: Container
+		}
+		Behavior { }
+	}
+	
+	ActorClass Container {
+		Structure {
+			conjugated Port p0: PC
+			Attribute caseId: int32
+			optional ActorRef opt: Optional2
+			
+			Binding p0 and opt.p0
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest5\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest5\", \"DynamicActorTest5_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			
+			// this method prints the passed message and then dumps the object tree consisting of actors and ports
+			Operation dumpTree(msg: string) {
+				"System.out.println(msg);"
+				"System.out.println(((org.eclipse.etrice.runtime.java.messaging.RTObject)getRoot()).toStringRecursive());"
+			}
+			
+			StateMachine {
+				Transition init: initial -> CreateOptional2 { }
+				Transition tr0: CreateOptional2 -> Done {
+					triggers {
+						<hello: p0>
+					}
+					action {
+						"dumpTree(\"after received hello\");"
+						""
+						"System.out.println(\"received \"+transitionData);"
+						""
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State CreateOptional2 {
+					entry {
+						"opt.createOptionalActor(\"Optional2\", getThread());"
+						"dumpTree(\"after creation of Optional2\");"
+						""
+						"// at this point the port isn\'t connected since"
+						"// the init message isn\'t processed yet"
+						"// - so no peer port exists"
+						"p0.sayHello();"
+					}
+				}
+				State Done
+			}
+		}
+	}
+	
+	ActorClass Optional1 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef sub1: AC1
+			Binding p0 and sub1.p0
+		}
+		Behavior { }
+	}
+	
+	ActorClass Optional2 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef sub2: AC2
+			Binding p0 and sub2.p0
+		}
+		Behavior { }
+	}
+	
+	// the following actor classes are part of the possible optional instance sub trees
+	
+	ActorClass AC1 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			external Port p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				State Ready {
+					entry {
+						"p0.hello(\"this is AC1, instance \"+getInstancePath());"
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass AC2 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			ActorRef deep_sub: AC3
+			Binding p0 and deep_sub.p0
+		}
+		Behavior { }
+	}
+	
+	ActorClass AC3 {
+		Interface {
+			Port p0: PC
+		}
+		Structure {
+			optional ActorRef nestedOpt: Optional1
+			Binding p0 and nestedOpt.p0
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				State Ready {
+					entry {
+						"nestedOpt.createOptionalActor(\"Optional1\", getThread());"
+					}
+				}
+			}
+		}
+	}
+	
+	// a simple protocol that is used to demonstrate that actors are connected
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest6.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest6.room
new file mode 100644
index 000000000..502efa7b0
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest6.room
@@ -0,0 +1,243 @@
+RoomModel DynamicActorTest6 {
+	
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	
+	ActorClass Appl {
+		@TestInstance
+		Structure {
+			ActorRef ctrl: Controller
+		}
+		Behavior { }
+	}
+	
+	ActorClass Controller {
+		Structure {
+			conjugated Port pcont: PCtrl
+			conjugated Port pout: PC
+			conjugated Port pin: PC
+			Attribute caseId: int32
+			ActorRef cont: Container
+			Binding pcont and cont.fct
+			Binding pout and cont.pin
+			Binding pin and cont.pout
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest6\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest6\", \"DynamicActorTest6_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			StateMachine {
+				Transition init: initial -> CreateOptionals { }
+				Transition tr0: CreateOptionals -> Sending {
+					triggers {
+						<done: pcont>
+					}
+				}
+				Transition tr1: Sending -> Destroy {
+					triggers {
+						<hello: pin>
+					}
+					action {
+						"System.out.println(\"Controller received: \"+transitionData);"
+					}
+				}
+				Transition tr2: Destroy -> CreateAgain {
+					triggers {
+						<done: pcont>
+					}
+				}
+				Transition tr3: CreateAgain -> SendAgain {
+					triggers {
+						<done: pcont>
+					}
+				}
+				Transition tr4: SendAgain -> Done {
+					triggers {
+						<hello: pin>
+					}
+					action {
+						"System.out.println(\"Controller received: \"+transitionData);"
+					}
+				}
+				State CreateOptionals {
+					entry {
+						"pcont.createOpts();"
+					}
+				}
+				State Sending {
+					entry {
+						"pout.sayHello();"
+					}
+				}
+				State Done {
+					entry {
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State Destroy {
+					entry {
+						"pcont.destroyOpts();"
+					}
+				}
+				State CreateAgain {
+					entry {
+						"pcont.createOpts();"
+					}
+				}
+				State SendAgain {
+					entry {
+						"pout.sayHello();"
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass Container {
+		Interface {
+			Port fct: PCtrl
+			Port pout: PC
+			Port pin: PC
+		}
+		Structure {
+			external Port fct
+			optional ActorRef opt1: Optional1
+			optional ActorRef opt2: Optional2
+			Binding opt1.pout and opt2.pin
+			Binding pin and opt1.pin
+			Binding pout and opt2.pout
+		}
+		Behavior {
+			// this method prints the passed message and then dumps the object tree consisting of actors and ports
+			Operation dumpTree(msg: string) {
+				"System.out.println(msg);"
+				"System.out.println(((org.eclipse.etrice.runtime.java.messaging.RTObject)getRoot()).toStringRecursive());"
+			}
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<createOpts: fct>
+					}
+					action {
+						"opt1.createOptionalActor(\"Optional1\", getThread());"
+						"opt2.createOptionalActor(\"Optional2\", getThread());"
+						"dumpTree(\"after creation of op1 and opt2\");"
+						"fct.done();"
+					}
+				}
+				Transition tr1: Ready -> Ready {
+					triggers {
+						<destroyOpts: fct>
+					}
+					action {
+						"opt1.destroyOptionalActor();"
+						"opt2.destroyOptionalActor();"
+						"fct.done();"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	ActorClass Optional1 {
+		Interface {
+			Port pout: PC
+			Port pin: PC
+		}
+		Structure {
+			ActorRef sub1: AC1
+			Binding pin and sub1.pin
+			Binding pout and sub1.pout
+		}
+		Behavior { }
+	}
+	
+	ActorClass Optional2 {
+		Interface {
+			Port pout: PC
+			conjugated Port pin: PC
+		}
+		Structure {
+			ActorRef sub2: AC2
+			Binding pout and sub2.pout
+			Binding pin and sub2.pin
+		}
+		Behavior { }
+	}
+	
+	ActorClass AC1 {
+		Interface {
+			Port pout: PC
+			Port pin: PC
+		}
+		Structure {
+			external Port pout
+			external Port pin
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<sayHello: pin>
+					}
+					action {
+						"pout.hello(\"this is AC1, instance \"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	ActorClass AC2 {
+		Interface {
+			Port pout: PC
+			conjugated Port pin: PC
+		}
+		Structure {
+			external Port pout
+			external Port pin
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<hello: pin>
+					}
+					action {
+						"System.out.println(\"AC2 received \"+transitionData);"
+						""
+						"pout.hello(\"AC2: forwarding \"+transitionData);"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+	
+	ProtocolClass PC {
+		incoming {
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+
+	ProtocolClass PCtrl {
+		incoming {
+			Message createOpts()
+			Message destroyOpts()
+		}
+		outgoing {
+			Message done()
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest7.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest7.room
new file mode 100644
index 000000000..84cf22e12
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/DynamicActorTest7.room
@@ -0,0 +1,375 @@
+RoomModel DynamicActorTest7 {
+
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+
+	LogicalSystem JavaGenTests {
+		SubSystemRef da7Test : SubSystem_DynamicActorTest7
+	}
+	
+	SubSystemClass SubSystem_DynamicActorTest7 {
+		ActorRef main : Appl
+	
+		LogicalThread defaultThread
+	}
+
+	ActorClass Appl {
+		Structure {
+			ActorRef cont: Container
+		}
+		Behavior { }
+	}
+
+	ActorClass Container {
+		Structure {
+			usercode1 {
+				"import java.io.File;"
+			}
+			usercode2 {
+				"private static final String FIRST_OPT_OBJ = \"firstOpt.obj\";"
+				"private static final String SECOND_OPT_OBJ = \"secondOpt.obj\";"
+			}
+			conjugated Port op: PStep
+			conjugated Port opa [*]: PStep
+			
+			Attribute caseId: int32
+			
+			optional ActorRef opt: Optional
+			optional ActorRef optarr [*]: Optional
+			
+			Binding op and opt.fct
+			Binding opa and optarr.fct
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest7\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest7\", \"DynamicActorTest7_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			Operation clean() {
+				"File f = new File(FIRST_OPT_OBJ);"
+				"if (f.exists())"
+				"\tf.delete();"
+			}
+			StateMachine {
+				Transition init: initial -> Init { }
+				Transition tr0: Init -> DestroyAndCreate {
+					triggers {
+						<hello: op>
+					}
+					action {
+						"System.out.println(\"received \"+transitionData);"
+					}
+				}
+				Transition tr1: DestroyAndCreate -> DestroyAndRestore {
+					triggers {
+						<hello: op>
+					}
+					action {
+						"System.out.println(\"received \"+transitionData);"
+					}
+				}
+				Transition tr2: DestroyAndRestore -> LoadInArray {
+					triggers {
+						<hello: op>
+					}
+					action {
+						"System.out.println(\"received \"+transitionData);"
+					}
+				}
+				Transition tr3: LoadInArray -> ReceivedHello {
+					triggers {
+						<hello: opa>
+					}
+					action {
+						"System.out.println(\"received \"+transitionData);"
+					}
+				}
+				Transition tr4: ReceivedHello -> Done {
+					triggers {
+						<hello: opa>
+					}
+					action {
+						"System.out.println(\"received \"+transitionData);"
+					}
+				}
+				State Init {
+					entry {
+						"clean();"
+						"FilePersistor.createAndLoad(opt, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
+						"op.step();"
+						"op.step();"
+						"op.sayHello();"
+					}
+				}
+				State DestroyAndCreate {
+					entry {
+						"FilePersistor.saveAndDestroy(opt, FIRST_OPT_OBJ);"
+						"FilePersistor.createAndLoad(opt, getThread(), SECOND_OPT_OBJ, \"Optional2\");"
+						"op.step();"
+						"op.step();"
+						"op.sayHello();"
+					}
+				}
+				State DestroyAndRestore {
+					entry {
+						"FilePersistor.saveAndDestroy(opt, SECOND_OPT_OBJ);"
+						"FilePersistor.createAndLoad(opt, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
+						"op.sayHello();"
+					}
+				}
+				State Done {
+					entry {
+						"IRTObject object = getObject(\"/JavaGenTests/da7Test/main/cont/optarr/optarr:0/sub\");"
+						"EXPECT_TRUE(caseId, \"object 0 of optarr is an instance of actor class Sub1\", object instanceof Sub1);"
+						""
+						"Sub1 inst = (Sub1) object;"
+						"EXPECT_EQUAL_INT32(caseId, \"state\", Sub1.STATE_Step3_StepA, inst.getState());"
+						"EXPECT_EQUAL_INT32(caseId, \"current value of ival\", 123, inst.getIval());"
+						"EXPECT_EQUAL_INT16(caseId, \"current value of sval\", (short)456, inst.getSval());"
+						"EXPECT_EQUAL_INT8(caseId, \"current value of bval\", (byte)3, inst.getBval());"
+						"EXPECT_TRUE(caseId, \"changed string\", \"changed\".equals(inst.getSome()[1].getStr()));"
+						"EXPECT_EQUAL_FLOAT32(caseId, \"current vaue of\", 3.14159f, inst.getDerived().getSome().getFval()[2], 0.001f);"
+						"EXPECT_EQUAL_UINT8(caseId, \"current value of cval\", 'x', inst.getCval());"
+						""
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State LoadInArray {
+					entry {
+						"FilePersistor.createAndLoad(optarr, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
+						"FilePersistor.createAndLoad(optarr, getThread(), SECOND_OPT_OBJ, \"Optional2\");"
+						"opa.sayHello();"
+					}
+				}
+				State ReceivedHello
+			}
+		}
+	}
+
+	abstract ActorClass Optional {
+		Interface {
+			Port fct: PStep
+		}
+		Structure { }
+		Behavior { }
+	}
+
+	ActorClass Optional1 extends Optional {
+		Structure {
+			ActorRef ^sub: Sub1
+			Binding fct and ^sub.fct
+		}
+		Behavior { }
+	}
+
+	ActorClass Optional2 extends Optional {
+		Structure {
+			ActorRef ^sub: Sub2
+			Binding fct and ^sub.fct
+		}
+		Behavior { }
+	}
+
+	ActorClass Sub1Base {
+		Structure {
+			Attribute cval: char
+		}
+	}
+	
+	ActorClass Sub1 extends Sub1Base {
+		Interface {
+			Port fct: PStep
+		}
+		Structure {
+			external Port fct
+			conjugated Port dp: PStep
+			
+			Attribute ival: int32
+			Attribute sval: int16
+			Attribute bval: int8
+			Attribute some[3]: SomeData
+			Attribute other: OtherData
+			Attribute derived: DerivedData
+			
+			ActorRef deep: DeepSub1
+			Binding dp and deep.fct
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Step1 { }
+				Transition tr0: Step1 -> Step2 {
+					triggers {
+						<step: fct>
+					}
+					action {
+						"dp.step();"
+					}
+				}
+				Transition tr1: Step2 -> Step3 {
+					triggers {
+						<step: fct>
+					}
+					action {
+						"dp.step();"
+					}
+				}
+				Transition tr2: my tp0 -> my tp0 {
+					triggers {
+						<sayHello: fct>
+					}
+					action {
+						"fct.hello(getClassName()+\", state=\"+stateStrings[getState()]+\", path= \"+getInstancePath());"
+					}
+				}
+				handler TransitionPoint tp0
+				State Step1 {
+					entry {
+						"ival = 1;"
+						"sval = 2;"
+						"bval = 3;"
+						"cval = 'x';"
+					}
+				}
+				State Step2 {
+					entry {
+						"ival = 123;"
+						"some[1].str = \"changed\";"
+						"derived.some.fval[2] = 3.14159f;"
+					}
+				}
+				State Step3 {
+					subgraph {
+						Transition init: initial -> StepA { }
+						Transition tr0: StepA -> StepB {
+							triggers {
+								<step: fct>
+							}
+							action {
+								"dp.step();"
+							}
+						}
+						Transition tr1: StepB -> StepC {
+							triggers {
+								<step: fct>
+							}
+							action {
+								"dp.step();"
+							}
+						}
+						State StepA {
+							entry {
+								"sval = 456;"
+							}
+						}
+						State StepB {
+							entry {
+								"bval = 13;"
+							}
+						}
+						State StepC
+					}
+				}
+			}
+		}
+	}
+
+	ActorClass DeepSub1 {
+		Interface {
+			Port fct: PStep
+		}
+		Structure {
+			external Port fct
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Step1 { }
+				Transition tr0: Step1 -> Step2 {
+					triggers {
+						<step: fct>
+					}
+				}
+				Transition tr1: Step2 -> Step3 {
+					triggers {
+						<step: fct>
+					}
+				}
+				Transition tr2: Step3 -> Step5 {
+					triggers {
+						<step: fct>
+					}
+				}
+				Transition tr3: Step5 -> Step6 {
+					triggers {
+						<step: fct>
+					}
+				}
+				Transition tr4: Step6 -> Step7 {
+					triggers {
+						<step: fct>
+					}
+				}
+				State Step1
+				State Step2
+				State Step3
+				State Step5
+				State Step6
+				State Step7
+			}
+		}
+	}
+
+	ActorClass Sub2 {
+		Interface {
+			Port fct: PStep
+		}
+		Structure {
+			external Port fct
+		}
+		Behavior {
+			StateMachine {
+				Transition init: initial -> Ready { }
+				Transition tr0: Ready -> Ready {
+					triggers {
+						<step: fct>
+					}
+				}
+				Transition tr1: Ready -> Ready {
+					triggers {
+						<sayHello: fct>
+					}
+					action {
+						"fct.hello(getClassName()+\", state=\"+stateStrings[getState()]+\", path= \"+getInstancePath());"
+					}
+				}
+				State Ready
+			}
+		}
+	}
+
+	ProtocolClass PStep {
+		incoming {
+			Message step()
+			Message sayHello()
+		}
+		outgoing {
+			Message hello(txt: string)
+		}
+	}
+
+	DataClass SomeData {
+		Attribute fval[3]: float32 = "1.0"
+		Attribute dval: float64 = "123.4"
+		Attribute str: string = "\"Text\""
+	}
+	
+	DataClass OtherData {
+		Attribute some: SomeData
+		Attribute bval: boolean = "false"
+	}
+	
+	DataClass DerivedData extends OtherData {
+		Attribute cval[3]: char = "{'a', 'b', 'c'}"
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/StoreRestore.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/StoreRestore.room
new file mode 100644
index 000000000..c8e56b9a9
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/StoreRestore.room
@@ -0,0 +1,217 @@
+RoomModel StoreRestore {
+
+	import room.basic.etunit.* from "Tests.room"
+
+	ActorClass StoreRestore_Top {
+		@TestInstance
+		Structure {
+			ActorRef tester: Tester
+			ActorRef testee: Testee
+			Binding tester.prt and testee.prt
+		}
+		Behavior { }
+	}
+
+	ActorClass Testee {
+		Interface {
+			Port prt: PC
+		}
+		Structure {
+			usercode1 { "import StoreRestore.ObjectHolder;" }
+			
+			external Port prt
+			
+			Attribute ival: int16
+			Attribute iarr [ 3 ]: int32
+			Attribute sdval: SomeData
+			Attribute sdarr [ 5 ]: SomeData
+			Attribute cdval: ComplexData
+		}
+		Behavior {
+			Operation doStore() {
+				"System.out.println(\"doStore()\");"
+				"IActorClassDataObject dataObject = newDataObject();"
+				"store(dataObject);"
+				"ObjectHolder.setObject(dataObject);"
+			}
+			Operation doRestore() {
+				"System.out.println(\"doRestore()\");"
+				"IActorClassDataObject dataObject = ObjectHolder.getObject();"
+				"restore(dataObject);"
+			}
+			StateMachine {
+				Transition tr0: my tp0 -> Restore {
+					triggers {
+						<restore: prt>
+					}
+				}
+				Transition init: initial -> Begin { }
+				Transition tr1: Begin -> Store {
+					triggers {
+						<step: prt>
+					}
+				}
+				Transition tr2: Store -> state2 {
+					triggers {
+						<step: prt>
+					}
+				}
+				Transition tr3: state2 -> state3 {
+					triggers {
+						<step: prt>
+					}
+				}
+				TransitionPoint tp0
+				State Begin {
+					entry {
+						"ival = 3;"
+					}
+				}
+				State Store {
+					entry {
+						"System.out.println(\"<|MODEL_LOCATION|>\");"
+						"setFinalAction(new SingleFinalAction() {"
+						"\tpublic void run() {"
+						"\t\tdoStore();"
+						"\t}"
+						"});"
+					}
+				}
+				State state2 {
+					entry {
+						"prt.valueIs(ival);"
+						""
+						"ival = 123;"
+					}
+				}
+				State Restore {
+					entry {
+						"System.out.println(\"<|MODEL_LOCATION|>\");"
+						"setFinalAction(new SingleFinalAction() {"
+						"\tpublic void run() {"
+						"\t\tdoRestore();"
+						"\t}"
+						"});"
+					}
+				}
+				State state3 {
+					entry {
+						"ival = 456;"
+						""
+						"prt.answer();"
+					}
+				}
+			}
+		}
+	}
+	
+	ActorClass Tester {
+		Interface {
+			conjugated Port prt: PC
+		}
+		Structure {
+			external Port prt
+			
+			Attribute caseId: int32
+			Attribute counter: int32 = "0"
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"StoreRestore\", \"org.eclipse.etrice.generator.common.tests.StoreRestore\", \"StoreRestore_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			
+			StateMachine {
+				Transition init: initial -> Prepare { }
+				Transition tr1: Loop2 -> cp cp0 {
+					triggers {
+						<answer: prt>
+					}
+				}
+				Transition tr2: cp cp0 -> Done
+				Transition tr3: cp cp0 -> Loop {
+					cond {
+						"++counter<10"
+					}
+				}
+				Transition tr0: Prepare -> Prepare2 {
+					triggers {
+						<valueIs: prt>
+					}
+					action {
+						"EXPECT_EQUAL_INT16(caseId, \"check old value <|MODEL_LOCATION|>\", (short)3, transitionData);"
+					}
+				}
+				Transition tr4: Prepare2 -> Loop {
+					triggers {
+						<answer: prt>
+					}
+				}
+				Transition tr5: Loop -> Loop2 {
+					triggers {
+						<valueIs: prt>
+					}
+					action {
+						"EXPECT_EQUAL_INT16(caseId, \"check old value <|MODEL_LOCATION|>\", (short)3, transitionData);"
+					}
+				}
+				ChoicePoint cp0
+				State Prepare {
+					entry {
+						"prt.step();"
+						"prt.step();"
+					}
+				}
+				State Loop {
+					entry {
+						"prt.restore();"
+						""
+						"prt.step();"
+						"prt.step();"
+					}
+				}
+				State Done {
+					entry {
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State Prepare2 {
+					entry {
+						"prt.step();"
+					}
+				}
+				State Loop2 {
+					entry {
+						"prt.step();"
+					}
+				}
+			}
+		}
+	}
+
+	ProtocolClass PC {
+		incoming {
+			Message step()
+			Message restore()
+		}
+		outgoing {
+			Message answer()
+			Message valueIs(val: int16)
+		}
+	}
+
+	DataClass SomeData {
+		Attribute ival: int16
+		Attribute iarr [ 3 ]: int32
+	}
+
+	DataClass ComplexData {
+		Attribute sdval: SomeData
+		Attribute sdarr [ 5 ]: SomeData
+	}
+
+	PrimitiveType int16: ptInteger -> 'short' (Short) default '0'
+	PrimitiveType int32: ptInteger -> 'int' (Integer) default '0'
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.generator.java.tests/targetModels/TCPTest.room b/tests/org.eclipse.etrice.generator.java.tests/targetModels/TCPTest.room
new file mode 100644
index 000000000..7508f94f1
--- /dev/null
+++ b/tests/org.eclipse.etrice.generator.java.tests/targetModels/TCPTest.room
@@ -0,0 +1,160 @@
+RoomModel TCPTest {
+
+	import room.basic.etunit.* from "Tests.room"
+	import room.basic.types.* from "Types.room"
+	import room.basic.service.tcp.* from "TcpService.room"
+	
+	ActorClass TCPTestTop {
+		@TestInstance
+		Structure {
+			ActorRef ref0: ATcpServer
+			ActorRef ref1 [ 5 ]: ATcpClient
+			ActorRef ref2: Tester
+			Binding ref2.p1 and ref0.PayloadPort
+			Binding ref2.p0 and ref0.ControlPort
+			Binding ref2.p2 and ref1.ControlPort
+			Binding ref2.p3 and ref1.PayloadPort
+		}
+		Behavior { }
+	}
+
+	ActorClass Tester {
+		Interface {
+			conjugated Port p0: PTcpControl
+			conjugated Port p1: PTcpPayload
+			conjugated Port p2 [*]: PTcpControl
+			conjugated Port p3 [5]: PTcpPayload
+		}
+		Structure {
+			external Port p0
+			external Port p1
+			external Port p2
+			external Port p3
+			Attribute controlData:DTcpControl
+			Attribute testData:DTcpPayload
+			Attribute counter:int32
+			Attribute resultPattern:int32
+			Attribute pattern:int32
+			Attribute caseId: int32
+			Attribute resultlist[3]: int16 = "{1,2,3}"
+			
+		}
+		Behavior {
+			ctor {
+				"caseId = etUnit_openAll(\"log/testlog\", \"TCPTest\", \"org.eclipse.etrice.generator.common.tests.TCPTest\", \"TCPTest_case\");"
+			}
+			dtor {
+				"etUnit_closeAll(caseId);"
+			}
+			StateMachine {
+				Transition init: initial -> state0 {
+					action {
+						"EXPECT_ORDER_START(caseId,resultlist,3);"
+						"EXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 1);"						
+						"// open Server"
+						"controlData.setIPAddr(\"127.0.0.1\");"
+						"controlData.setTcpPort(4711);"
+						"p0.open(controlData);"
+					}
+				}
+				Transition tr0: state0 -> state1 {
+					triggers {
+						<established: p0>
+					}
+					action {
+						"// open 5 clients"
+						"for (int i=0;i<p2.getReplication();i++){"
+						"p2[i].open(controlData);"
+						"}"
+						"counter=0;"
+					}
+				}
+				Transition tr1: state1 -> cp cp0 {
+					triggers {
+						<established: p2>
+					}
+					action {
+						"counter++;"
+					}
+				}
+				Transition tr4: cp cp0 -> state1
+				Transition tr5: cp cp0 -> state2 {
+					cond {
+						"counter>=p2.getReplication()"
+					}
+					action {
+						"String s=new String (\"Test!\");"
+						"testData.setData(s.getBytes());"
+						"testData.setLength(s.length());"
+						"testData.setConnectionId(0);"
+						"for (int i=0; i<p3.getReplication();i++){"
+						"\tp3[i].send(testData);"
+						"}"
+						"counter=0;"
+						"resultPattern=0;"
+					}
+				}
+				Transition tr8: state2 -> cp cp2 {
+					triggers {
+						<receive: p3>
+					}
+					action {
+						"resultPattern+=p3.getIndexOf(ifitem);"
+						"//System.out.printf(\"c:%d, Idx:%d!\\n\", counter,p3.getIndexOf(ifitem));"
+						"counter++;"
+					}
+				}
+				Transition tr9: cp cp2 -> state2
+				Transition tr10: cp cp2 -> cp cp1 {
+					cond {
+						"counter>=p2.getReplication()"
+					}
+					action {
+						"int i;"
+						"p0.close();"
+						"// close all clients"
+						"p2.close();"
+						"pattern=0;"
+						"for (i=0;i<p2.getReplication();i++){"
+						"\tpattern+=i;"
+						"}"
+					}
+				}
+				Transition tr3: state2 -> state2 {
+					triggers {
+						<receive: p1>
+					}
+					action {
+						"p1.send(transitionData);"
+					}
+				}
+				Transition tr2: cp cp1 -> test_failed
+				Transition tr6: cp cp1 -> test_ok {
+					cond {
+						"pattern==resultPattern"
+					}
+				}
+				ChoicePoint cp0
+				ChoicePoint cp2
+				ChoicePoint cp1
+				State state0
+				State state1
+				State state2
+				State test_ok {
+					entry {
+						"EXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 2);"
+						"EXPECT_ORDER_END(caseId,\"<|MODEL_LOCATION|>\", 3);"
+						"etUnit_testFinished(caseId);"
+					}
+				}
+				State test_failed {
+					entry {
+						"EXPECT_ORDER(caseId,\"<|MODEL_LOCATION|>\", 0xFF);"
+						"EXPECT_ORDER_END(caseId,\"<|MODEL_LOCATION|>\", 3);"
+						"etUnit_testFinished(caseId);"
+					}
+				}
+			}
+		}
+	}
		
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.runtime.java.tests/org.eclipse.etrice.runtime.java.tests.launch b/tests/org.eclipse.etrice.runtime.java.tests/org.eclipse.etrice.runtime.java.tests.launch
index d9ad1884a..7a1d37c5c 100644
--- a/tests/org.eclipse.etrice.runtime.java.tests/org.eclipse.etrice.runtime.java.tests.launch
+++ b/tests/org.eclipse.etrice.runtime.java.tests/org.eclipse.etrice.runtime.java.tests.launch
@@ -10,6 +10,7 @@
 <booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
 <stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
 <stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value=""/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.etrice.runtime.java.tests"/>
 <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.etrice.ui.behavior.tests/META-INF/MANIFEST.MF
index c8f7920c5..4d200de66 100644
--- a/tests/org.eclipse.etrice.ui.behavior.tests/META-INF/MANIFEST.MF
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/META-INF/MANIFEST.MF
@@ -17,7 +17,9 @@ Require-Bundle: org.eclipse.etrice.core.fsm;bundle-version="1.1.1",
  org.eclipse.core.runtime,
  org.junit;bundle-version="4.8.1",
  org.eclipse.xtext;bundle-version="2.6.0",
- org.eclipse.graphiti;bundle-version="0.8.0"
+ org.eclipse.graphiti;bundle-version="0.8.0",
+ org.eclipse.etrice.core.room.tests;bundle-version="1.1.1",
+ org.eclipse.etrice.core.genmodel.fsm;bundle-version="1.1.1"
 Import-Package: org.eclipse.xtext.xbase.lib
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Base.behavior b/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Base.behavior
new file mode 100644
index 000000000..510dfad28
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Base.behavior
@@ -0,0 +1,341 @@
+<?xml version="1.0" encoding="ASCII"?>
+<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of Base" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@children.0/@children.6/@link //@children.1/@link //@children.1/@children.1/@link //@children.0/@children.4/@children.1/@link //@children.1/@children.2/@link //@children.0/@children.4/@children.2/@link //@connections.0/@link //@connections.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link" verticalGridUnit="10" version="0.13.0">
+  <graphicsAlgorithm xsi:type="al:Rectangle" background="//@colors.1" foreground="//@colors.0" lineWidth="1" transparency="0.0" width="1000" height="1000"/>
+  <link>
+    <businessObjects href="../InheritedStateMachine.room#ActorClass:Base"/>
+  </link>
+  <children xsi:type="pi:ContainerShape" visible="true" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#StateGraph:Base$sg"/>
+    </link>
+    <children visible="true">
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="40" height="40" x="100" y="100">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="10" y="10"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#StateGraph:Base$sg"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.0" referencedGraphicsAlgorithm="//@children.0/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="40" height="20" y="10" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="I"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="tp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="40">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.2" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#TransitionPoint:Base$tp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" referencedGraphicsAlgorithm="//@children.0/@children.2/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="100" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Base$b0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.1" incomingConnections="//@connections.0" referencedGraphicsAlgorithm="//@children.0/@children.3/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="260" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Base$b1"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" referencedGraphicsAlgorithm="//@children.0/@children.4/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b1"/>
+      </children>
+      <children xsi:type="pi:ContainerShape" visible="true" active="true">
+        <properties key="obj-type" value="trp"/>
+        <properties key="item-kind" value="entp"/>
+        <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="60" height="60" x="6">
+          <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="11" height="11" x="25" y="25"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0">
+            <points x="27" y="33"/>
+            <points x="33" y="27"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0">
+            <points x="27" y="27"/>
+            <points x="33" y="33"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithm>
+        <link>
+          <businessObjects href="../InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+        </link>
+        <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.3" referencedGraphicsAlgorithm="//@children.0/@children.4/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+        <children visible="true">
+          <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="22" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+        </children>
+      </children>
+      <children xsi:type="pi:ContainerShape" visible="true" active="true">
+        <properties key="obj-type" value="trp"/>
+        <properties key="item-kind" value="extp"/>
+        <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="60" height="60" x="15">
+          <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="11" height="11" x="25" y="25"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0" x="25" y="25">
+            <points x="5"/>
+            <points x="11" y="5"/>
+            <points x="5" y="11"/>
+            <points y="5"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithm>
+        <link>
+          <businessObjects href="../InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+        </link>
+        <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.4" referencedGraphicsAlgorithm="//@children.0/@children.4/@children.2/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+        <children visible="true">
+          <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="22" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp1"/>
+        </children>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="420" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.3" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Base$b2"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.2 //@connections.4" referencedGraphicsAlgorithm="//@children.0/@children.5/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b2"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="50" height="50" x="55" y="265">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="25" height="25" x="12" y="12"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#ChoicePoint:Base$cp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.2 //@connections.3" incomingConnections="//@connections.1" referencedGraphicsAlgorithm="//@children.0/@children.6/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="50" height="25" y="12" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="C"/>
+      </children>
+    </children>
+  </children>
+  <children xsi:type="pi:ContainerShape" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#StateGraph:Base$b1$sg"/>
+    </link>
+    <children>
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/b1"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="entp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="80">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+        <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="2" filled="false" transparency="0.0">
+          <points x="33" y="47"/>
+          <points x="47" y="33"/>
+        </graphicsAlgorithmChildren>
+        <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="2" filled="false" transparency="0.0">
+          <points x="33" y="33"/>
+          <points x="47" y="47"/>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="extp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="200">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+        <graphicsAlgorithmChildren xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="2" filled="true" transparency="0.0" x="30" y="30">
+          <points x="10"/>
+          <points x="20" y="10"/>
+          <points x="10" y="20"/>
+          <points y="10"/>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" verticalAlignment="ALIGNMENT_BOTTOM" value="tp1"/>
+      </children>
+    </children>
+  </children>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.1/@anchors.0" end="//@children.0/@children.3/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#InitialTransition:Base$initial"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="init"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.3/@anchors.0" end="//@children.0/@children.6/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#TriggeredTransition:Base$tr0"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr0: &lt;x:p0>"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.6/@anchors.0" end="//@children.0/@children.5/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#ContinuationTransition:Base$tr1"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr1: [else]"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.6/@anchors.0" end="//@children.0/@children.4/@children.1/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#CPBranchTransition:Base$tr2"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr2: [true]"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.4/@children.2/@anchors.0" end="//@children.0/@children.5/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#ContinuationTransition:Base$tr3"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr3: "/>
+    </connectionDecorators>
+  </connections>
+  <colors red="227" green="238" blue="249"/>
+  <colors red="255" green="255" blue="255"/>
+  <colors/>
+  <colors red="200" green="200" blue="200"/>
+  <fonts name="Arial" size="8"/>
+  <fonts name="Arial" size="9" bold="true"/>
+</pi:Diagram>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Derived.behavior b/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Derived.behavior
new file mode 100644
index 000000000..50f9fda19
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/models/diagrams/InheritedStateMachine.Derived.behavior
@@ -0,0 +1,452 @@
+<?xml version="1.0" encoding="ASCII"?>
+<pi:Diagram xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:al="http://eclipse.org/graphiti/mm/algorithms" xmlns:pi="http://eclipse.org/graphiti/mm/pictograms" visible="true" gridUnit="10" diagramTypeId="room.behavior" name="Behavior of Derived" pictogramLinks="//@link //@children.0/@link //@children.0/@children.1/@link //@children.0/@children.2/@link //@children.0/@children.3/@link //@children.0/@children.4/@link //@children.0/@children.5/@link //@children.0/@children.6/@link //@children.1/@link //@children.1/@children.1/@link //@children.0/@children.4/@children.1/@link //@children.1/@children.2/@link //@children.0/@children.4/@children.2/@link //@children.1/@children.3/@link //@connections.0/@link //@connections.1/@link //@children.2/@link //@children.2/@children.1/@link //@connections.2/@link //@connections.3/@link //@connections.4/@link //@connections.5/@link //@connections.6/@link" verticalGridUnit="10" version="0.13.0">
+  <graphicsAlgorithm xsi:type="al:Rectangle" background="//@colors.1" foreground="//@colors.0" lineWidth="1" transparency="0.0" width="1000" height="1000"/>
+  <link>
+    <businessObjects href="../InheritedStateMachine.room#ActorClass:Derived"/>
+  </link>
+  <children xsi:type="pi:ContainerShape" visible="true" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#StateGraph:Derived$sg"/>
+    </link>
+    <children visible="true">
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="40" height="40" x="100" y="100">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.2" lineWidth="2" transparency="0.0" width="20" height="20" x="10" y="10"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#StateGraph:Derived$sg"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.2" referencedGraphicsAlgorithm="//@children.0/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="40" height="20" y="10" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="I"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="tp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="40">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.3" foreground="//@colors.3" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#TransitionPoint:Base$tp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" referencedGraphicsAlgorithm="//@children.0/@children.2/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="100" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.4" foreground="//@colors.3" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Base$b0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.3" incomingConnections="//@connections.2" referencedGraphicsAlgorithm="//@children.0/@children.3/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="260" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.4" foreground="//@colors.3" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#RefinedState:Derived$b1"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" referencedGraphicsAlgorithm="//@children.0/@children.4/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b1"/>
+      </children>
+      <children xsi:type="pi:ContainerShape" visible="true" active="true">
+        <properties key="obj-type" value="trp"/>
+        <properties key="item-kind" value="entp"/>
+        <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="60" height="60" x="6">
+          <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.3" lineWidth="1" transparency="0.0" width="11" height="11" x="25" y="25"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0">
+            <points x="27" y="33"/>
+            <points x="33" y="27"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0">
+            <points x="27" y="27"/>
+            <points x="33" y="33"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithm>
+        <link>
+          <businessObjects href="../InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+        </link>
+        <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.5" referencedGraphicsAlgorithm="//@children.0/@children.4/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+        <children visible="true">
+          <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="60" height="22" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+        </children>
+      </children>
+      <children xsi:type="pi:ContainerShape" visible="true" active="true">
+        <properties key="obj-type" value="trp"/>
+        <properties key="item-kind" value="extp"/>
+        <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="60" height="60" x="15">
+          <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.3" lineWidth="1" transparency="0.0" width="11" height="11" x="25" y="25"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0" x="25" y="25">
+            <points x="5"/>
+            <points x="11" y="5"/>
+            <points x="5" y="11"/>
+            <points y="5"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithm>
+        <link>
+          <businessObjects href="../InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+        </link>
+        <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.6" referencedGraphicsAlgorithm="//@children.0/@children.4/@children.2/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+        <children visible="true">
+          <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="60" height="22" font="//@fonts.0" verticalAlignment="ALIGNMENT_BOTTOM" value="tp1"/>
+        </children>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="420" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.4" foreground="//@colors.3" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="true" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.3" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#RefinedState:Derived$b2"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.4 //@connections.6" referencedGraphicsAlgorithm="//@children.0/@children.5/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="b2"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" visible="true" active="true">
+      <properties key="obj-type" value="trp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="50" height="50" x="55" y="265">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.3" lineWidth="2" transparency="0.0" width="25" height="25" x="12" y="12"/>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#ChoicePoint:Base$cp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.4 //@connections.5" incomingConnections="//@connections.3" referencedGraphicsAlgorithm="//@children.0/@children.6/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children visible="true">
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="50" height="25" y="12" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="C"/>
+      </children>
+    </children>
+  </children>
+  <children xsi:type="pi:ContainerShape" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#StateGraph:Derived$b1$sg"/>
+    </link>
+    <children>
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/b1"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="entp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="80">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.3" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+        <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="2" filled="false" transparency="0.0">
+          <points x="33" y="47"/>
+          <points x="47" y="33"/>
+        </graphicsAlgorithmChildren>
+        <graphicsAlgorithmChildren xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="2" filled="false" transparency="0.0">
+          <points x="33" y="33"/>
+          <points x="47" y="47"/>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.0"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" verticalAlignment="ALIGNMENT_BOTTOM" value="tp0"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="trp"/>
+      <properties key="item-kind" value="extp"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="80" height="80" x="200">
+        <graphicsAlgorithmChildren xsi:type="al:Ellipse" background="//@colors.1" foreground="//@colors.3" lineWidth="2" transparency="0.0" width="20" height="20" x="30" y="30"/>
+        <graphicsAlgorithmChildren xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="2" filled="true" transparency="0.0" x="30" y="30">
+          <points x="10"/>
+          <points x="20" y="10"/>
+          <points x="10" y="20"/>
+          <points y="10"/>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" incomingConnections="//@connections.1"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.3" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" width="80" height="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" verticalAlignment="ALIGNMENT_BOTTOM" value="tp1"/>
+      </children>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="20" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.5" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Derived$b1$d11"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" outgoingConnections="//@connections.1" incomingConnections="//@connections.0" referencedGraphicsAlgorithm="//@children.1/@children.3/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="d11"/>
+      </children>
+    </children>
+  </children>
+  <children xsi:type="pi:ContainerShape" active="true">
+    <properties key="obj-type" value="sg"/>
+    <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="880" height="580" x="40" y="40">
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.1" foreground="//@colors.2" lineWidth="4" transparency="0.5" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+      <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="4" filled="false" transparency="0.0" width="800" height="500" x="40" y="40" cornerHeight="20" cornerWidth="20"/>
+    </graphicsAlgorithm>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#StateGraph:Derived$b2$sg"/>
+    </link>
+    <children>
+      <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="800" height="80" y="40" font="//@fonts.1" horizontalAlignment="ALIGNMENT_RIGHT" verticalAlignment="ALIGNMENT_TOP" value="/b2"/>
+    </children>
+    <children xsi:type="pi:ContainerShape" active="true">
+      <properties key="obj-type" value="state"/>
+      <graphicsAlgorithm xsi:type="al:Rectangle" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="120" height="90" x="20" y="120">
+        <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" background="//@colors.5" foreground="//@colors.2" lineWidth="1" transparency="0.0" width="60" height="30" x="30" y="30" cornerHeight="20" cornerWidth="20">
+          <graphicsAlgorithmChildren xsi:type="al:RoundedRectangle" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" width="15" height="8" x="35" y="3" cornerHeight="5" cornerWidth="5"/>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-3" y="-3"/>
+            <points x="-3" y="3"/>
+            <points x="-11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="3" y="-3"/>
+            <points x="3" y="3"/>
+            <points x="11" y="3"/>
+          </graphicsAlgorithmChildren>
+          <graphicsAlgorithmChildren xsi:type="al:Polygon" foreground="//@colors.2" lineWidth="1" filled="false" lineVisible="false" transparency="0.0" x="30" y="24">
+            <points x="-2" y="-3"/>
+            <points x="-2" y="3"/>
+            <points x="2" y="3"/>
+            <points x="2" y="-3"/>
+          </graphicsAlgorithmChildren>
+        </graphicsAlgorithmChildren>
+      </graphicsAlgorithm>
+      <link>
+        <businessObjects href="../InheritedStateMachine.room#SimpleState:Derived$b2$d21"/>
+      </link>
+      <anchors xsi:type="pi:ChopboxAnchor" referencedGraphicsAlgorithm="//@children.2/@children.1/@graphicsAlgorithm/@graphicsAlgorithmChildren.0"/>
+      <children>
+        <graphicsAlgorithm xsi:type="al:Text" background="//@colors.2" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" width="60" height="30" x="30" y="30" font="//@fonts.0" horizontalAlignment="ALIGNMENT_CENTER" value="d21"/>
+      </children>
+    </children>
+  </children>
+  <connections xsi:type="pi:FreeFormConnection" active="true" start="//@children.1/@children.1/@anchors.0" end="//@children.1/@children.3/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#ContinuationTransition:Derived$b1$tr0"/>
+    </link>
+    <connectionDecorators locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr0: "/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" active="true" start="//@children.1/@children.3/@anchors.0" end="//@children.1/@children.2/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#TriggeredTransition:Derived$b1$tr1"/>
+    </link>
+    <connectionDecorators locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.2" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.2" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr1: &lt;x:p0>"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.1/@anchors.0" end="//@children.0/@children.3/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#InitialTransition:Base$initial"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="init"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.3/@anchors.0" end="//@children.0/@children.6/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#TriggeredTransition:Base$tr0"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr0: &lt;x:p0>"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.6/@anchors.0" end="//@children.0/@children.5/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#ContinuationTransition:Base$tr1"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr1: [else]"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.6/@anchors.0" end="//@children.0/@children.4/@children.1/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#CPBranchTransition:Base$tr2"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr2: [true]"/>
+    </connectionDecorators>
+  </connections>
+  <connections xsi:type="pi:FreeFormConnection" visible="true" active="true" start="//@children.0/@children.4/@children.2/@anchors.0" end="//@children.0/@children.5/@anchors.0">
+    <properties key="obj-type" value="trans"/>
+    <graphicsAlgorithm xsi:type="al:Polyline" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0"/>
+    <link>
+      <businessObjects href="../InheritedStateMachine.room#ContinuationTransition:Base$tr3"/>
+    </link>
+    <connectionDecorators visible="true" locationRelative="true" location="1.0">
+      <graphicsAlgorithm xsi:type="al:Polygon" background="//@colors.1" foreground="//@colors.3" lineWidth="1" filled="true" transparency="0.0">
+        <points x="-15" y="5"/>
+        <points/>
+        <points x="-15" y="-5"/>
+      </graphicsAlgorithm>
+    </connectionDecorators>
+    <connectionDecorators visible="true" active="true" locationRelative="true" location="0.5">
+      <graphicsAlgorithm xsi:type="al:Text" foreground="//@colors.3" lineWidth="1" filled="false" transparency="0.0" x="10" font="//@fonts.0" value="tr3: "/>
+    </connectionDecorators>
+  </connections>
+  <colors red="227" green="238" blue="249"/>
+  <colors red="255" green="255" blue="255"/>
+  <colors/>
+  <colors red="100" green="100" blue="100"/>
+  <colors red="230" green="230" blue="230"/>
+  <colors red="200" green="200" blue="200"/>
+  <fonts name="Arial" size="8"/>
+  <fonts name="Arial" size="9" bold="true"/>
+</pi:Diagram>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/output/Base.fsmgen b/tests/org.eclipse.etrice.ui.behavior.tests/output/Base.fsmgen
new file mode 100644
index 000000000..8e4ad56d6
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/output/Base.fsmgen
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="ASCII"?>
+<fsmgen:GraphContainer xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:fsmgen="http://www.eclipse.org/etrice/generator/fsm">
+  <graph>
+    <nodes outgoing="//@graph/@links.2 //@graph/@links.3" incoming="//@graph/@links.1">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ChoicePoint:Base$cp0"/>
+    </nodes>
+    <nodes>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TransitionPoint:Base$tp0"/>
+    </nodes>
+    <nodes outgoing="//@graph/@links.1" incoming="//@graph/@links.0">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Base$b0"/>
+    </nodes>
+    <nodes>
+      <subgraph>
+        <nodes incoming="//@graph/@links.3">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+        </nodes>
+        <nodes outgoing="//@graph/@links.4">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+        </nodes>
+        <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:Base$b1$sg"/>
+      </subgraph>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Base$b1"/>
+    </nodes>
+    <nodes incoming="//@graph/@links.2 //@graph/@links.4">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Base$b2"/>
+    </nodes>
+    <links target="//@graph/@nodes.2">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#InitialTransition:Base$initial"/>
+    </links>
+    <links source="//@graph/@nodes.2" target="//@graph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TriggeredTransition:Base$tr0"/>
+    </links>
+    <links source="//@graph/@nodes.0" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr1"/>
+    </links>
+    <links source="//@graph/@nodes.0" target="//@graph/@nodes.3/@subgraph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#CPBranchTransition:Base$tr2"/>
+    </links>
+    <links source="//@graph/@nodes.3/@subgraph/@nodes.1" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr3"/>
+    </links>
+    <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:Base$sg"/>
+  </graph>
+  <component href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ActorClass:Base"/>
+</fsmgen:GraphContainer>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/output/Derived.fsmgen b/tests/org.eclipse.etrice.ui.behavior.tests/output/Derived.fsmgen
new file mode 100644
index 000000000..a2a66226f
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/output/Derived.fsmgen
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="ASCII"?>
+<fsmgen:GraphContainer xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:fsmgen="http://www.eclipse.org/etrice/generator/fsm">
+  <graph>
+    <nodes inherited="true" outgoing="//@graph/@links.2 //@graph/@links.3" incoming="//@graph/@links.1">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ChoicePoint:Base$cp0"/>
+    </nodes>
+    <nodes inherited="true">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TransitionPoint:Base$tp0"/>
+    </nodes>
+    <nodes inherited="true" outgoing="//@graph/@links.1" incoming="//@graph/@links.0">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Base$b0"/>
+    </nodes>
+    <nodes inherited="true">
+      <subgraph>
+        <nodes inherited="true" outgoing="//@graph/@nodes.3/@subgraph/@links.0" incoming="//@graph/@links.3">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+        </nodes>
+        <nodes inherited="true" outgoing="//@graph/@links.4" incoming="//@graph/@nodes.3/@subgraph/@links.1">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+        </nodes>
+        <nodes outgoing="//@graph/@nodes.3/@subgraph/@links.1" incoming="//@graph/@nodes.3/@subgraph/@links.0" inheritanceLevel="1">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Derived$b1$d11"/>
+        </nodes>
+        <links source="//@graph/@nodes.3/@subgraph/@nodes.0" target="//@graph/@nodes.3/@subgraph/@nodes.2">
+          <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Derived$b1$tr0"/>
+        </links>
+        <links source="//@graph/@nodes.3/@subgraph/@nodes.2" target="//@graph/@nodes.3/@subgraph/@nodes.1">
+          <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TriggeredTransition:Derived$b1$tr1"/>
+        </links>
+        <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:Derived$b1$sg"/>
+      </subgraph>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:Derived$b1"/>
+    </nodes>
+    <nodes inherited="true" incoming="//@graph/@links.2 //@graph/@links.4">
+      <subgraph>
+        <nodes inheritanceLevel="1">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Derived$b2$d21"/>
+        </nodes>
+        <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:Derived$b2$sg"/>
+      </subgraph>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:Derived$b2"/>
+    </nodes>
+    <links inherited="true" target="//@graph/@nodes.2">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#InitialTransition:Base$initial"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.2" target="//@graph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TriggeredTransition:Base$tr0"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.0" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr1"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.0" target="//@graph/@nodes.3/@subgraph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#CPBranchTransition:Base$tr2"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.3/@subgraph/@nodes.1" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr3"/>
+    </links>
+    <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:Derived$sg"/>
+  </graph>
+  <component href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ActorClass:Derived"/>
+</fsmgen:GraphContainer>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/output/DoubleDerived.fsmgen b/tests/org.eclipse.etrice.ui.behavior.tests/output/DoubleDerived.fsmgen
new file mode 100644
index 000000000..57c3ec88f
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/output/DoubleDerived.fsmgen
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="ASCII"?>
+<fsmgen:GraphContainer xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:fsmgen="http://www.eclipse.org/etrice/generator/fsm">
+  <graph>
+    <nodes inherited="true" outgoing="//@graph/@links.2 //@graph/@links.3" incoming="//@graph/@links.1">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ChoicePoint:Base$cp0"/>
+    </nodes>
+    <nodes inherited="true">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TransitionPoint:Base$tp0"/>
+    </nodes>
+    <nodes inherited="true" outgoing="//@graph/@links.1" incoming="//@graph/@links.0">
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:Base$b0"/>
+    </nodes>
+    <nodes inherited="true">
+      <subgraph>
+        <nodes inherited="true" outgoing="//@graph/@nodes.3/@subgraph/@links.0" incoming="//@graph/@links.3">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#EntryPoint:Base$b1$tp0"/>
+        </nodes>
+        <nodes inherited="true" outgoing="//@graph/@links.4" incoming="//@graph/@nodes.3/@subgraph/@links.1">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ExitPoint:Base$b1$tp1"/>
+        </nodes>
+        <nodes inherited="true" outgoing="//@graph/@nodes.3/@subgraph/@links.1" incoming="//@graph/@nodes.3/@subgraph/@links.0" inheritanceLevel="1">
+          <subgraph>
+            <nodes inheritanceLevel="2">
+              <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:DoubleDerived$b1$d11$dd111"/>
+            </nodes>
+            <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:DoubleDerived$b1$d11$sg"/>
+          </subgraph>
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:DoubleDerived$b1$d11"/>
+        </nodes>
+        <nodes inheritanceLevel="2">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:DoubleDerived$b1$dd12"/>
+        </nodes>
+        <nodes inheritanceLevel="2">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:DoubleDerived$b1$dd13"/>
+        </nodes>
+        <links inherited="true" source="//@graph/@nodes.3/@subgraph/@nodes.0" target="//@graph/@nodes.3/@subgraph/@nodes.2">
+          <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Derived$b1$tr0"/>
+        </links>
+        <links inherited="true" source="//@graph/@nodes.3/@subgraph/@nodes.2" target="//@graph/@nodes.3/@subgraph/@nodes.1">
+          <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TriggeredTransition:Derived$b1$tr1"/>
+        </links>
+        <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:DoubleDerived$b1$sg"/>
+      </subgraph>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:DoubleDerived$b1"/>
+    </nodes>
+    <nodes inherited="true" incoming="//@graph/@links.2 //@graph/@links.4">
+      <subgraph>
+        <nodes inherited="true" inheritanceLevel="1">
+          <subgraph>
+            <nodes inheritanceLevel="2">
+              <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:DoubleDerived$b2$d21$dd211"/>
+            </nodes>
+            <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:DoubleDerived$b2$d21$sg"/>
+          </subgraph>
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:DoubleDerived$b2$d21"/>
+        </nodes>
+        <nodes inheritanceLevel="2">
+          <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#SimpleState:DoubleDerived$b2$xt2"/>
+        </nodes>
+        <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:DoubleDerived$b2$sg"/>
+      </subgraph>
+      <stateGraphNode href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#RefinedState:DoubleDerived$b2"/>
+    </nodes>
+    <links inherited="true" target="//@graph/@nodes.2">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#InitialTransition:Base$initial"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.2" target="//@graph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#TriggeredTransition:Base$tr0"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.0" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr1"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.0" target="//@graph/@nodes.3/@subgraph/@nodes.0">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#CPBranchTransition:Base$tr2"/>
+    </links>
+    <links inherited="true" source="//@graph/@nodes.3/@subgraph/@nodes.1" target="//@graph/@nodes.4">
+      <transition href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ContinuationTransition:Base$tr3"/>
+    </links>
+    <stateGraph href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#StateGraph:DoubleDerived$sg"/>
+  </graph>
+  <component href="file:/C:/Users/hrentz.PROTOS/git/newfsmgen/org.eclipse.etrice/tests/org.eclipse.etrice.ui.behavior.tests/models/InheritedStateMachine.room#ActorClass:DoubleDerived"/>
+</fsmgen:GraphContainer>
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/src/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.xtend b/tests/org.eclipse.etrice.ui.behavior.tests/src/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.xtend
new file mode 100644
index 000000000..455c952e4
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/src/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.xtend
@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * 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.commands
+
+import com.google.common.collect.Sets
+import java.util.List
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.etrice.core.RoomStandaloneSetup
+import org.eclipse.etrice.core.TestBase
+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.IDiagnostician
+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.Link
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node
+import org.eclipse.etrice.core.room.ActorClass
+import org.eclipse.etrice.core.room.RoomModel
+import org.eclipse.etrice.ui.behavior.BehaviorTestActivator
+import org.junit.Test
+
+import static org.junit.Assert.assertEquals
+import static org.junit.Assert.assertFalse
+import static org.junit.Assert.assertNotNull
+import static org.junit.Assert.assertTrue
+
+class TestFSMGenModel extends TestBase {
+
+	val injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration()
+	protected IDiagnostician diagnostician = new NullDiagnostician
+	protected extension ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(injector, diagnostician)
+
+	protected def createResourceSetWithGc(String roomFile, String actorName) {
+		prepare(BehaviorTestActivator.^default.getBundle())
+		val res = getResource(roomFile)
+		val actor = (res.contents.get(0) as RoomModel).actorClasses.findFirst[name.equals(actorName)]	
+		
+		val gc = builder.createTransformedModel(actor) => [gc |
+			assertNotNull("graph context was created", gc)
+			
+			val logger = new NullLogger
+			FsmGenChecker.check(gc, logger)
+			assertFalse("logger has no errors", logger.hasErrors)
+			save(gc, actor.name)
+		]
+		
+		res.resourceSet.createResource(URI.createURI('dummy://' + actorName + '.fsmgen')) => [
+			contents += gc
+		]
+		
+		return res.resourceSet
+	}
+	
+	protected def save(GraphContainer gc, String fileName) {
+		val rs = new ResourceSetImpl
+		val uri = URI.createFileURI("./output/" + fileName + ".fsmgen")
+		val res = rs.createResource(uri)
+		res.contents.add(gc)
+		res.save(newHashMap)
+	}
+	
+	@Test
+	def void testBaseClass() {
+		val rs = createResourceSetWithGc("InheritedStateMachine.room", "Base")
+		val actorClasses = EcoreUtil.getAllContents(rs, true).filter(ActorClass).filter[name == 'Base'].toList
+		val gc = rs.resources.map[contents].flatten.filter(GraphContainer).head
+		
+		checkAgainstRoom(gc, actorClasses)
+	}
+	
+	@Test
+	def void testDerivedClass() {
+		val rs = createResourceSetWithGc("InheritedStateMachine.room", "Derived")
+		val actorClasses = EcoreUtil.getAllContents(rs, true).filter(ActorClass).filter[name == 'Base' || name == 'Derived'].toList
+		val gc = rs.resources.map[contents].flatten.filter(GraphContainer).head
+		
+		checkAgainstRoom(gc, actorClasses)
+	}
+	
+	@Test
+	def void testDoubleDerivedClass() {
+		val rs = createResourceSetWithGc("InheritedStateMachine.room", "DoubleDerived")
+		val actorClasses = EcoreUtil.getAllContents(rs, true).filter(ActorClass).filter[name == 'Base' || name == 'Derived' || name == 'DoubleDerived'].toList
+		val gc = rs.resources.map[contents].flatten.filter(GraphContainer).head
+		
+		checkAgainstRoom(gc, actorClasses)
+	}
+	
+	def void checkAgainstRoom(GraphContainer gc, List<ActorClass> actorClasses) {
+		// genmodel should refer to latest fsm	(check in-memory ref)
+		val genModelRefs = (EcoreUtil.getAllContents(gc, true).filter(Node).map[stateGraphNode] + EcoreUtil.getAllContents(gc, true).filter(Link).map[transition]).toSet
+		EcoreUtil.getAllContents(actorClasses.last, false).filter(StateGraphItem).forEach[
+			assertTrue('missing ' + EcoreUtil.getURI(it), genModelRefs.contains(it))
+		]
+		
+		// all fsm items should be in genmodel	(check name) 
+		// node, there are duplicate names in subgraphs => not complete
+		val stateGraphItemsNames = EcoreUtil.getAllContents(actorClasses, true).filter(StateGraphItem).map[name].toIterable.toSortedSet
+		val namesFromGenModel = genModelRefs.map[name].toSortedSet	
+		assertEquals(stateGraphItemsNames, namesFromGenModel)
+	}
+	
+	private def <T extends Comparable> toSortedSet(Iterable<T> iterable) {
+		 Sets.<T>newTreeSet(iterable)
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.etrice.ui.behavior.tests/xtend-gen/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.java b/tests/org.eclipse.etrice.ui.behavior.tests/xtend-gen/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.java
new file mode 100644
index 000000000..7535dfc38
--- /dev/null
+++ b/tests/org.eclipse.etrice.ui.behavior.tests/xtend-gen/org/eclipse/etrice/ui/behavior/commands/TestFSMGenModel.java
@@ -0,0 +1,177 @@
+/**
+ * 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.commands;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Sets;
+import com.google.inject.Injector;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.etrice.core.RoomStandaloneSetup;
+import org.eclipse.etrice.core.TestBase;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphItem;
+import org.eclipse.etrice.core.fsm.fSM.StateGraphNode;
+import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
+import org.eclipse.etrice.core.genmodel.fsm.ExtendedFsmGenBuilder;
+import org.eclipse.etrice.core.genmodel.fsm.FsmGenChecker;
+import org.eclipse.etrice.core.genmodel.fsm.IDiagnostician;
+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.Link;
+import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.ui.behavior.BehaviorTestActivator;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+import org.junit.Assert;
+import org.junit.Test;
+
+@SuppressWarnings("all")
+public class TestFSMGenModel extends TestBase {
+  private final Injector injector = new RoomStandaloneSetup().createInjectorAndDoEMFRegistration();
+  
+  protected IDiagnostician diagnostician = new NullDiagnostician();
+  
+  @Extension
+  protected ExtendedFsmGenBuilder builder = new ExtendedFsmGenBuilder(this.injector, this.diagnostician);
+  
+  protected ResourceSet createResourceSetWithGc(final String roomFile, final String actorName) {
+    this.prepare(BehaviorTestActivator.getDefault().getBundle());
+    final Resource res = this.getResource(roomFile);
+    EObject _get = res.getContents().get(0);
+    final Function1<ActorClass, Boolean> _function = (ActorClass it) -> {
+      return Boolean.valueOf(it.getName().equals(actorName));
+    };
+    final ActorClass actor = IterableExtensions.<ActorClass>findFirst(((RoomModel) _get).getActorClasses(), _function);
+    GraphContainer _createTransformedModel = this.builder.createTransformedModel(actor);
+    final Procedure1<GraphContainer> _function_1 = (GraphContainer gc) -> {
+      Assert.assertNotNull("graph context was created", gc);
+      final NullLogger logger = new NullLogger();
+      FsmGenChecker.check(gc, logger);
+      Assert.assertFalse("logger has no errors", logger.hasErrors());
+      this.save(gc, actor.getName());
+    };
+    final GraphContainer gc = ObjectExtensions.<GraphContainer>operator_doubleArrow(_createTransformedModel, _function_1);
+    Resource _createResource = res.getResourceSet().createResource(URI.createURI((("dummy://" + actorName) + ".fsmgen")));
+    final Procedure1<Resource> _function_2 = (Resource it) -> {
+      EList<EObject> _contents = it.getContents();
+      _contents.add(gc);
+    };
+    ObjectExtensions.<Resource>operator_doubleArrow(_createResource, _function_2);
+    return res.getResourceSet();
+  }
+  
+  protected void save(final GraphContainer gc, final String fileName) {
+    try {
+      final ResourceSetImpl rs = new ResourceSetImpl();
+      final URI uri = URI.createFileURI((("./output/" + fileName) + ".fsmgen"));
+      final Resource res = rs.createResource(uri);
+      res.getContents().add(gc);
+      res.save(CollectionLiterals.<Object, Object>newHashMap());
+    } catch (Throwable _e) {
+      throw Exceptions.sneakyThrow(_e);
+    }
+  }
+  
+  @Test
+  public void testBaseClass() {
+    final ResourceSet rs = this.createResourceSetWithGc("InheritedStateMachine.room", "Base");
+    final Function1<ActorClass, Boolean> _function = (ActorClass it) -> {
+      String _name = it.getName();
+      return Boolean.valueOf(Objects.equal(_name, "Base"));
+    };
+    final List<ActorClass> actorClasses = IteratorExtensions.<ActorClass>toList(IteratorExtensions.<ActorClass>filter(Iterators.<ActorClass>filter(EcoreUtil.<Object>getAllContents(rs, true), ActorClass.class), _function));
+    final Function1<Resource, EList<EObject>> _function_1 = (Resource it) -> {
+      return it.getContents();
+    };
+    final GraphContainer gc = IterableExtensions.<GraphContainer>head(Iterables.<GraphContainer>filter(Iterables.<EObject>concat(ListExtensions.<Resource, EList<EObject>>map(rs.getResources(), _function_1)), GraphContainer.class));
+    this.checkAgainstRoom(gc, actorClasses);
+  }
+  
+  @Test
+  public void testDerivedClass() {
+    final ResourceSet rs = this.createResourceSetWithGc("InheritedStateMachine.room", "Derived");
+    final Function1<ActorClass, Boolean> _function = (ActorClass it) -> {
+      return Boolean.valueOf((Objects.equal(it.getName(), "Base") || Objects.equal(it.getName(), "Derived")));
+    };
+    final List<ActorClass> actorClasses = IteratorExtensions.<ActorClass>toList(IteratorExtensions.<ActorClass>filter(Iterators.<ActorClass>filter(EcoreUtil.<Object>getAllContents(rs, true), ActorClass.class), _function));
+    final Function1<Resource, EList<EObject>> _function_1 = (Resource it) -> {
+      return it.getContents();
+    };
+    final GraphContainer gc = IterableExtensions.<GraphContainer>head(Iterables.<GraphContainer>filter(Iterables.<EObject>concat(ListExtensions.<Resource, EList<EObject>>map(rs.getResources(), _function_1)), GraphContainer.class));
+    this.checkAgainstRoom(gc, actorClasses);
+  }
+  
+  @Test
+  public void testDoubleDerivedClass() {
+    final ResourceSet rs = this.createResourceSetWithGc("InheritedStateMachine.room", "DoubleDerived");
+    final Function1<ActorClass, Boolean> _function = (ActorClass it) -> {
+      return Boolean.valueOf(((Objects.equal(it.getName(), "Base") || Objects.equal(it.getName(), "Derived")) || Objects.equal(it.getName(), "DoubleDerived")));
+    };
+    final List<ActorClass> actorClasses = IteratorExtensions.<ActorClass>toList(IteratorExtensions.<ActorClass>filter(Iterators.<ActorClass>filter(EcoreUtil.<Object>getAllContents(rs, true), ActorClass.class), _function));
+    final Function1<Resource, EList<EObject>> _function_1 = (Resource it) -> {
+      return it.getContents();
+    };
+    final GraphContainer gc = IterableExtensions.<GraphContainer>head(Iterables.<GraphContainer>filter(Iterables.<EObject>concat(ListExtensions.<Resource, EList<EObject>>map(rs.getResources(), _function_1)), GraphContainer.class));
+    this.checkAgainstRoom(gc, actorClasses);
+  }
+  
+  public void checkAgainstRoom(final GraphContainer gc, final List<ActorClass> actorClasses) {
+    final Function1<Node, StateGraphNode> _function = (Node it) -> {
+      return it.getStateGraphNode();
+    };
+    Iterator<StateGraphNode> _map = IteratorExtensions.<Node, StateGraphNode>map(Iterators.<Node>filter(EcoreUtil.<Object>getAllContents(gc, true), Node.class), _function);
+    final Function1<Link, TransitionBase> _function_1 = (Link it) -> {
+      return it.getTransition();
+    };
+    Iterator<TransitionBase> _map_1 = IteratorExtensions.<Link, TransitionBase>map(Iterators.<Link>filter(EcoreUtil.<Object>getAllContents(gc, true), Link.class), _function_1);
+    final Set<StateGraphItem> genModelRefs = IteratorExtensions.<StateGraphItem>toSet(Iterators.<StateGraphItem>concat(_map, _map_1));
+    final Procedure1<StateGraphItem> _function_2 = (StateGraphItem it) -> {
+      URI _uRI = EcoreUtil.getURI(it);
+      String _plus = ("missing " + _uRI);
+      Assert.assertTrue(_plus, genModelRefs.contains(it));
+    };
+    IteratorExtensions.<StateGraphItem>forEach(Iterators.<StateGraphItem>filter(EcoreUtil.<Object>getAllContents(IterableExtensions.<ActorClass>last(actorClasses), false), StateGraphItem.class), _function_2);
+    final Function1<StateGraphItem, String> _function_3 = (StateGraphItem it) -> {
+      return it.getName();
+    };
+    final TreeSet<String> stateGraphItemsNames = this.<String>toSortedSet(IteratorExtensions.<String>toIterable(IteratorExtensions.<StateGraphItem, String>map(Iterators.<StateGraphItem>filter(EcoreUtil.<Object>getAllContents(actorClasses, true), StateGraphItem.class), _function_3)));
+    final Function1<StateGraphItem, String> _function_4 = (StateGraphItem it) -> {
+      return it.getName();
+    };
+    final TreeSet<String> namesFromGenModel = this.<String>toSortedSet(IterableExtensions.<StateGraphItem, String>map(genModelRefs, _function_4));
+    Assert.assertEquals(stateGraphItemsNames, namesFromGenModel);
+  }
+  
+  private <T extends Comparable> TreeSet<T> toSortedSet(final Iterable<T> iterable) {
+    return Sets.<T>newTreeSet(iterable);
+  }
+}