diff --git a/src/main/jastadd/io/IoPN.jadd b/src/main/jastadd/io/IoPN.jadd
index 5a37d6028d8813d51b225921c1d3a24ac53d44c3..94491dc8c6d117956321a96b4cebff09027e00fb 100644
--- a/src/main/jastadd/io/IoPN.jadd
+++ b/src/main/jastadd/io/IoPN.jadd
@@ -12,11 +12,14 @@ aspect IoPnExtension{
 
         eq Page.getObject().containingPlace() = null;
 
-        syn lazy JastAddList<InputSignalBinding> InputSignalTransition.getInputSignalBindingList() {
+        syn lazy JastAddList<InputSignalBinding> InputSignalTransition.getStaticInputSignalBindingList() {
 
-            JastAddList<InputSignalBinding> isBindings = de.tudresden.inf.st.postprocessing.IoPetriNetPostProcessor.parseInputSignalBindingDefinitions(this.getToolspecificList());
+            if(this.getMutualInputSignalBindingList() == null || this.getMutualInputSignalBindingList().getNumChild() == 0){
+                JastAddList<InputSignalBinding> isBindings = de.tudresden.inf.st.postprocessing.IoPetriNetPostProcessor.parseInputSignalBindingDefinitions(this.getToolspecificList());
+                return isBindings;
+            }
 
-            return isBindings;
+            return this.getMutualInputSignalBindingList();
         }
 
         syn lazy JastAddList<OutputSignalBinding> OutputSignalPlace.getOutputSignalBindingList() {
diff --git a/src/main/jastadd/io/IoPN.relast b/src/main/jastadd/io/IoPN.relast
index 38fd19c687f1ff230ccd2e844bdb8af0208faef5..bbacff9c267461a6e95522762ebbd9bbe4c2c743 100644
--- a/src/main/jastadd/io/IoPN.relast
+++ b/src/main/jastadd/io/IoPN.relast
@@ -3,7 +3,7 @@ OutputSignalBinding : PnObject ::= <PlaceID:String> <OutputSignalID:String> /<Ou
 TransitionInformation ::= <Location:String> <Type:String> <InputLimit:java.lang.Integer> <OutputLimit:java.lang.Integer> <Topic:String> <SubNet:String>;
 PlaceInformation ::= <Location:String> <Type:String> <SubNet:String>;
 
-InputSignalTransition : Transition ::= /InputSignalBinding*/ /TransitionInformation/;
+InputSignalTransition : Transition ::= /StaticInputSignalBinding:InputSignalBinding*/  MutualInputSignalBinding:InputSignalBinding* /TransitionInformation/;
 OutputSignalPlace : Place ::= /OutputSignalBinding*/;
 
 OutputMapping;
diff --git a/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java b/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
index 92d279fe2d6c7bd58cb0e323c23116ffd8e0707f..cba194517949471ad2fa77062af54541c5cad88c 100644
--- a/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
+++ b/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
@@ -4,7 +4,19 @@ import de.tudresden.inf.st.pnml.PnmlConstants;
 import de.tudresden.inf.st.pnml.jastadd.model.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.StringWriter;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -12,19 +24,19 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
 
     private static final Logger logger = LoggerFactory.getLogger(GlobalToLocalNetsPostProcessor.class);
 
-    public static PetriNet disconnectNets(PetriNet petriNet){
+    public static PetriNet disconnectNets(PetriNet petriNet) {
 
         printNet(petriNet);
 
         Set<Transition> transitionsToAdd = new HashSet<>();
         Set<Transition> transitionsToRemove = new HashSet<>();
 
-        for(Transition transition : petriNet.allTransitions()){
+        for (Transition transition : petriNet.allTransitions()) {
 
             InputSignalTransition channelIst = transition.asInputSignalTransition();
-           // logger.error("infos: " + channelIst.getTransitionInformation());
+            // logger.error("infos: " + channelIst.getTransitionInformation());
 
-            if(channelIst.getTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC)){
+            if (channelIst.getTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC)) {
 
                 logger.info("Found topic transition: " + transition.getId());
 
@@ -39,13 +51,13 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
                 String inSubNet = null;
                 String outSubNet = null;
 
-                for(Place p : channelIst.incomingPlaces()){
+                for (Place p : channelIst.incomingPlaces()) {
                     inLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
                     inSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
                     break;
                 }
 
-                for(Place p : channelIst.outgoingPlaces()){
+                for (Place p : channelIst.outgoingPlaces()) {
                     outLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
                     outSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
                     break;
@@ -58,45 +70,64 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
                 sourceIst.getTransitionInformation().setSubNet(inSubNet);
                 sourceIst.getTransitionInformation().setLocation(inLocation);
 
-                // TODO: the attributized infos need to be written back to XML
-                sourceIst.setToolspecificList(new JastAddList<>());
+                // attributized infos need to be written back to XML
+                JastAddList<ToolInfo> inputToolInfoJastAddList = new JastAddList<>();
 
-                if(channelIst.getTransitionInformation().getInputLimit() >= 0 ){
+                if (channelIst.getTransitionInformation().getInputLimit() >= 0) {
                     sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_OUT);
-                }else{
+                    inputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_OUT, inLocation, inSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), channelIst.getStaticInputSignalBindingList()));
+                } else {
                     sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_OUT);
+                    inputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_OUT, inLocation, inSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), channelIst.getStaticInputSignalBindingList()));
                 }
 
+                sourceIst.setToolspecificList(inputToolInfoJastAddList);
+
                 InputSignalTransition targetIst = new InputSignalTransition();
                 targetIst.setName(new Name().setText(channelIst.getName().getText() + "-target"));
                 targetIst.setId(channelIst.getId() + "-target");
                 targetIst.getTransitionInformation().setSubNet(outSubNet);
                 targetIst.getTransitionInformation().setLocation(outLocation);
 
-                // TODO: the attributized infos need to be written back to XML
-                targetIst.setToolspecificList(new JastAddList<>());
+                // attributized infos need to be written back to XML
+                JastAddList<ToolInfo> outputToolInfoJastAddList = new JastAddList<>();
 
-                if(channelIst.getTransitionInformation().getOutputLimit() >= 0 ){
+                targetIst.setToolspecificList(outputToolInfoJastAddList);
+
+                if (channelIst.getTransitionInformation().getOutputLimit() >= 0) {
                     targetIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_IN);
-                }else{
+                    outputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_IN, outLocation, outSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), null));
+                } else {
                     targetIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_IN);
+                    outputToolInfoJastAddList.add(buildToolSpecifics(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_IN, outLocation, outSubNet,
+                            channelIst.getTransitionInformation().getInputLimit(), channelIst.getTransitionInformation().getOutputLimit(), null));
                 }
 
 
                 // STEP 2: Reconnect Input Signals
-                //for(InputSignalBinding isb : channelIst.getInputSignalBindingList()){
-                //    inputIst.addInputSignalBinding(isb);
-                //}
+                for(InputSignalBinding isb : channelIst.getMutualInputSignalBindingList()){
+
+                    InputSignalBinding newIsb = new InputSignalBinding();
+                    newIsb.setInputSignalValue(isb.getInputSignalValue());
+                    newIsb.setTransitionID(isb.getTransitionID());
+                    newIsb.setId(isb.getId());
+                    newIsb.setInputSignalID(isb.getInputSignalID());
+
+                    sourceIst.addMutualInputSignalBinding(newIsb);
+                }
 
                 // STEP 3: Get all incoming arcs and connect them to new output transition
-                for(Arc arc : channelIst.getInArcList().toArray(new Arc[0])){
+                for (Arc arc : channelIst.getInArcList().toArray(new Arc[0])) {
                     arc.setTarget(sourceIst);
                     logger.error("###");
                     //break;
                 }
 
                 // STEP 4: Gel all outgoing arcs and connect them to new input transition
-                for(Arc arc : channelIst.getOutArcList().toArray(new Arc[0])){
+                for (Arc arc : channelIst.getOutArcList().toArray(new Arc[0])) {
                     arc.setSource(targetIst);
                     logger.error("+++");
                     //break;
@@ -109,12 +140,12 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         }
 
         // STEP 6: Remove "old transition"
-        for (Transition t: transitionsToRemove){
+        for (Transition t : transitionsToRemove) {
             t.removeSelf();
         }
 
         //petriNet.allTransitions().removeAll(transitionsToRemove);
-        for(Transition t: transitionsToAdd){
+        for (Transition t : transitionsToAdd) {
             petriNet.getPage(0).addObject(t);
         }
 
@@ -126,32 +157,113 @@ public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
         return petriNet;
     }
 
-    private static StringBuffer buildToolSpecifics(String type, String location, String subnet, String inputLimit, String outputLimit){
+    private static ToolInfo buildToolSpecifics(String type, String location, String subnet, int inputLimit, int outputLimit, JastAddList<InputSignalBinding> inputSignalBindings) {
+
+        try {
+            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
+            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
+
+            Document doc = docBuilder.newDocument();
+            Element rootElement = doc.createElement("toolspecific");
+            rootElement.setAttribute("tool", "de.tudresden.inf.st.pnml.distributedPN");
+            rootElement.setAttribute("version", "0.0.1");
+            doc.appendChild(rootElement);
+
+            Element loc = doc.createElement("location");
+            loc.appendChild(doc.createTextNode(location));
+            rootElement.appendChild(loc);
+
+            Element ctype = doc.createElement("type");
+            ctype.appendChild(doc.createTextNode(type));
+            rootElement.appendChild(ctype);
+
+            Element net = doc.createElement("subnet");
+            net.appendChild(doc.createTextNode(subnet));
+            rootElement.appendChild(net);
+
+            Element inLimit = doc.createElement("inputlimit");
+            inLimit.appendChild(doc.createTextNode(String.valueOf(inputLimit)));
+            rootElement.appendChild(inLimit);
+
+            Element outLimit = doc.createElement("outputlimit");
+            outLimit.appendChild(doc.createTextNode(String.valueOf(outputLimit)));
+            rootElement.appendChild(outLimit);
+
+            Element bindings = doc.createElement("inputsignalbindings");
+
+            for(InputSignalBinding isb : inputSignalBindings){
+
+                Element binding = doc.createElement("inputsignalbinding");
+
+                Element transitionID = doc.createElement("transitionID");
+                transitionID.appendChild(doc.createTextNode(isb.getTransitionID()));
+                binding.appendChild(transitionID);
+
+                Element inputsignalID = doc.createElement("inputsignalID");
+                inputsignalID.appendChild(doc.createTextNode(isb.getInputSignalID()));
+                binding.appendChild(inputsignalID);
+
+                Element initialvalue = doc.createElement("initialvalue");
+                initialvalue.appendChild(doc.createTextNode(String.valueOf(isb.getInputSignalValue())));
+                binding.appendChild(initialvalue);
+
+                bindings.appendChild(binding);
+            }
+
+            rootElement.appendChild(bindings);
+
+            TransformerFactory tf = TransformerFactory.newInstance();
+            Transformer trans = tf.newTransformer();
+            StringWriter sw = new StringWriter();
+            trans.transform(new DOMSource(doc), new StreamResult(sw));
+
+            ToolInfo toolInfo = new ToolInfo();
+            toolInfo.setFormattedXMLBuffer(sw.getBuffer());
+            toolInfo.setVersion("0.0.1");
+            toolInfo.setTool("de.tudresden.inf.st.pnml.distributedPN");
+
+            return toolInfo;
+        } catch (ParserConfigurationException | TransformerConfigurationException pce) {
+            pce.printStackTrace();
+        } catch (TransformerException e) {
+            e.printStackTrace();
+        }
 
-        // TODO TBD
         return null;
     }
 
-    private static void printNet(PetriNet petriNet){
+    private static void printNet(PetriNet petriNet) {
 
-        for(Transition t : petriNet.allTransitions()){
+        logger.info("--------------- STRUCTURE ---------------");
 
-            logger.info("--- Transiton: " + t.getName().getText() +  " ---------");
+        for (Transition t : petriNet.allTransitions()) {
 
-            for(Place p : t.asInputSignalTransition().incomingPlaces()){
+            logger.info("--- Transiton: " + t.getName().getText() + " ---------");
 
-                logger.info("------ Inputplace:  " + p.getName().getText()+  " ---------");
+            for (Place p : t.asInputSignalTransition().incomingPlaces()) {
+
+                logger.info("------ Inputplace:  " + p.getName().getText() + " ---------");
             }
 
-            for(Place p : t.asInputSignalTransition().outgoingPlaces()){
+            for (Place p : t.asInputSignalTransition().outgoingPlaces()) {
 
-                logger.info("------ Outputplace: " + p.getName().getText()+  " ---------");
+                logger.info("------ Outputplace: " + p.getName().getText() + " ---------");
             }
         }
 
-        for(Arc a : petriNet.allArcs()){
+        for (Arc a : petriNet.allArcs()) {
 
             logger.info("Arc: " + a.getId() + " -- source: " + a.getSource().getName().getText() + " -- target: " + a.getTarget().getName().getText());
         }
+
+        logger.info("--------------- SIGNALS ---------------");
+
+        for (Transition t : petriNet.allTransitions()) {
+            InputSignalTransition ist = t.asInputSignalTransition();
+
+            if (ist != null && ist.getStaticInputSignalBindingList() != null) {
+                ist.getStaticInputSignalBindingList().forEach(inputSignalBinding -> logger.info(" (" + t.getName().getText() + ") Signal: " + inputSignalBinding.getInputSignalID()));
+            }
+        }
     }
 }
diff --git a/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java b/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
index a13b6652bcfc288b0cea48104387619c04376e6b..2c06d896d58d54029fc4a1eccc80e714f0933684 100644
--- a/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
+++ b/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
@@ -36,6 +36,8 @@ public class IoPetriNetPostProcessor implements PostProcessor<PetriNet> {
 
     private static JastAddList<InputSignalBinding> parseInputSignalBindingDefinitionsInternal(Document doc) {
 
+        logger.error("!!!");
+
         NodeList isBindingDefList = doc.getElementsByTagName(PnmlConstants.INPUT_SIGNAL_BINDINGS_KEY);
         JastAddList<InputSignalBinding> jastAddBindingList = new JastAddList<>();
 
@@ -167,8 +169,6 @@ public class IoPetriNetPostProcessor implements PostProcessor<PetriNet> {
 
         Document doc = dBuilder.parse(fromStringBuffer(toolInfoStringBuffer));
         doc.getDocumentElement().normalize();
-
-        logger.error("############################# tttttttttttttttttttttttt");
         return doc;
     }