diff --git a/src/app/project/game-model/gamesystems/ProductGamesystem.ts b/src/app/project/game-model/gamesystems/ProductGamesystem.ts
index 08f793b..3984e2d 100644
--- a/src/app/project/game-model/gamesystems/ProductGamesystem.ts
+++ b/src/app/project/game-model/gamesystems/ProductGamesystem.ts
@@ -68,202 +68,8 @@ export class ProductGamesystem extends Gamesystem<ProductState, ProductTransitio
   }
 
   generateFromChildsystems() {
-    //Assume that childsystems that are productsystems are already generated
-    if(this.innerGamesystems.length < 2) {
-      //currently only safe-guard
-      return;
-    }
-
-    const integratedSystems: Gamesystem<any, any>[] = [this.innerGamesystems[0], this.innerGamesystems[1]];
-    if(this.innerGamesystems[0] instanceof ProductGamesystem) {
-      this.innerGamesystems[0].generateFromChildsystems();
-    }
-
-    if(this.innerGamesystems[1] instanceof ProductGamesystem) {
-      this.innerGamesystems[1].generateFromChildsystems();
-    }
-    let gamesystem: ProductGamesystem  = ProductGamesystem.generateFromChildsystems(this.innerGamesystems[0], this.innerGamesystems[1], false, integratedSystems);
-
-    for(let i=2; i<this.innerGamesystems.length; i++) {
-      if(this.innerGamesystems[i] instanceof ProductGamesystem) {
-        (this.innerGamesystems[i] as ProductGamesystem).generateFromChildsystems();
-      }
-      integratedSystems.push(this.innerGamesystems[i]);
-      gamesystem = ProductGamesystem.generateFromChildsystems(gamesystem, this.innerGamesystems[i], true, integratedSystems);
-    }
-    this.states = gamesystem.states;
-    this.transitions = gamesystem.transitions;
-  }
-
-  static generateFromChildsystems(leftSystem: Gamesystem<any, any>, rightSystem: Gamesystem<any, any>, left_temp: boolean, integratedSystems: Gamesystem<any, any>[]) {
-    const productGamesystem = new ProductGamesystem("Temporary Gamesystem", "");
-    integratedSystems.forEach(integratedSystem => productGamesystem.addChildGamesystem(integratedSystem));
-
-    leftSystem.states.forEach(leftState => {
-      rightSystem.states.forEach(rightState => {
-        for(let i=0; i<leftState.outgoingTransitions.length; i++) {
-          for(let j=0; j<rightState.outgoingTransitions.length; j++) {
-            const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
-
-            if(startingState != undefined) {
-              const endingState_right = productGamesystem.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, left_temp);
-              if(endingState_right != undefined) {
-                const transition_right = productGamesystem.createTransition(startingState, endingState_right);
-                if(transition_right != undefined) {
-                  transition_right.scriptAccountActions = [...rightState.outgoingTransitions[j].scriptAccountActions]
-                  transition_right.scriptAccountConditions = [... rightState.outgoingTransitions[j].scriptAccountConditions]
-                }
-              }
-
-              const endingState_left = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, left_temp);
-              if(endingState_left != undefined) {
-                const transition_left = productGamesystem.createTransition(startingState, endingState_left);
-                if(transition_left != undefined) {
-                  transition_left.scriptAccountActions = [... leftState.outgoingTransitions[i].scriptAccountActions]
-                  transition_left.scriptAccountConditions = [...leftState.outgoingTransitions[i].scriptAccountConditions]
-                }
-              }
-
-
-              const endingState_left_right = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, left_temp);
-              if(endingState_left_right != undefined) {
-                const leftConditions = leftState.outgoingTransitions[i].scriptAccountConditions;
-                const rightConditions = rightState.outgoingTransitions[j].scriptAccountConditions;
-                if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
-                  const transition_left_right = productGamesystem.createTransition(startingState, endingState_left_right)!;
-
-                  if(transition_left_right != undefined) {
-                    transition_left_right.scriptAccountActions = this.generateCombinedActions(leftState.outgoingTransitions[i].scriptAccountActions, rightState.outgoingTransitions[j].scriptAccountActions)
-                    transition_left_right.scriptAccountConditions = this.generateCombinedConditions(leftState.outgoingTransitions[i].scriptAccountConditions, rightState.outgoingTransitions[j].scriptAccountConditions)
-                  }
-                }
-
-              }
-            }
-
-          }
-
-          if(rightState.outgoingTransitions.length == 0) {
-            const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
-            const endingState = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, left_temp);
-
-            if(startingState != undefined && endingState != undefined) {
-              const transition = productGamesystem.createTransition(startingState, endingState);
-              if(transition != undefined) {
-                transition.scriptAccountActions = [... leftState.outgoingTransitions[i].scriptAccountActions]
-                transition.scriptAccountConditions = [...leftState.outgoingTransitions[i].scriptAccountConditions]
-              }
-            }
-          }
-        }
-
-        if(leftState.outgoingTransitions.length == 0) {
-          for(let j=0; j<rightState.outgoingTransitions.length; j++) {
-            const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
-            const endingState = productGamesystem.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, left_temp);
-
-            if(startingState != undefined && endingState != undefined) {
-              const transition = productGamesystem.createTransition(startingState, endingState);
-              if(transition != undefined) {
-                transition.scriptAccountActions = [... rightState.outgoingTransitions[j].scriptAccountActions]
-                transition.scriptAccountConditions = [...rightState.outgoingTransitions[j].scriptAccountConditions]
-              }
-            }
-
-          }
-        }
-      })
-    })
-
-
-    return productGamesystem;
-  }
-
-  private static generateCombinedActions(leftActions: ScriptAccountAction[], rightActions: ScriptAccountAction[]) {
-    const combinedActions: ScriptAccountAction[] = []
-    for(let i=0; i<leftActions.length; i++) {
-      for(let j=0; j<rightActions.length; j++) {
-        const combinedAction = leftActions[i].combineActions(rightActions[j])
-        if(combinedAction == undefined) {
-          if(!combinedActions.includes(leftActions[i])) {
-            combinedActions.push(leftActions[i])
-          }
-
-          if(!combinedActions.includes(rightActions[j])) {
-            combinedActions.push(rightActions[j])
-          }
-        } else {
-
-          combinedActions.push(combinedAction)
-        }
-      }
-    }
-    return combinedActions;
-  }
-
-  private static generateCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]) {
-    const combinedConditions: ScriptAccountCondition[] = [];
-    for(let i=0; i<leftConditions.length; i++) {
-      for(let j=0; j<rightConditions.length; j++) {
-        const combinedCondition = leftConditions[i].combineCondition(rightConditions[j]);
-        if(combinedCondition == undefined) {
-          if(!combinedConditions.includes(leftConditions[i])) {
-            combinedConditions.push(leftConditions[i])
-          }
-
-          if(!combinedConditions.includes(rightConditions[j])) {
-            combinedConditions.push(rightConditions[j])
-          }
-        } else {
-          combinedConditions.push(combinedCondition)
-        }
-      }
-    }
-    return combinedConditions;
-  }
-
-  private static contradictCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]): boolean {
-    for(let i=0; i<leftConditions.length; i++) {
-      for(let j=0; j<rightConditions.length; j++) {
-        if(leftConditions[i].isContradicting(rightConditions[j])) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  generateBinaryProductState(leftInnerState: State<any>, rightInnerState: State<any>, left_temp: boolean) {
-    const combinedStateConditions: ScriptAccountCondition[] = leftInnerState.conditions.concat(rightInnerState.conditions)
-    for(let i=0; i<combinedStateConditions.length; i++) {
-      for(let j=0; j<combinedStateConditions.length; j++) {
-        if(combinedStateConditions[i].isContradicting(combinedStateConditions[j])) {
-          return undefined
-        }
-      }
-    }
-
-    let innerStates: State<any>[] = [];
-    if(!left_temp) {
-      innerStates = [leftInnerState, rightInnerState];
-    } else {
-      const left_inner_product_state = leftInnerState as ProductState;
-      left_inner_product_state.innerStates.forEach(state => innerStates.push(state));
-      innerStates.push(rightInnerState);
-    }
-
-
-    let binary_productState = this.findProductStateByInnerStates(innerStates);
-    if(binary_productState == undefined) {
-      binary_productState =  this.createState(innerStates)!;
-    }
-
-    let productInitial = true;
-    binary_productState.innerStates.forEach(innerState => productInitial = productInitial && innerState.initial)
-    binary_productState!.initial = productInitial
-    binary_productState.conditions = combinedStateConditions
-
-    return binary_productState!;
+    console.log("Debug msg")
+    this.productGamesystemGenerator.generateFromChildsystems()
   }
 
   addChildGamesystem(gamesystem: Gamesystem<State<any>, Transition<any>>) {
diff --git a/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts b/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
index b2986cf..ec4fa25 100644
--- a/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
+++ b/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
@@ -23,15 +23,23 @@ export class ProductGamesystemGenerator {
     const rightInitialData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[1])
 
     const initialGenerationResult = this.generateFromBinaryChildsystems(leftInitialData, rightInitialData);
+    if(this.productGamesystem.innerGamesystems.length > 2) {
+      for(let i=2; i<this.productGamesystem.innerGamesystems.length; i++) {
+        const leftData = initialGenerationResult.productGenerationData;
+        const rightData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[i]);
 
-    for(let i=2; i<this.productGamesystem.innerGamesystems.length; i++) {
-      const leftData = initialGenerationResult.productGenerationData;
-      const rightData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[i]);
-
-      const generationResult = this.generateFromBinaryChildsystems(leftData, rightData);
-      this.productGamesystem.states = generationResult.states;
-      this.productGamesystem.transitions = generationResult.transitions;
+        const generationResult = this.generateFromBinaryChildsystems(leftData, rightData);
+        this.productGamesystem.states = generationResult.states;
+        this.productGamesystem.transitions = generationResult.transitions;
+      }
+    } else {
+      this.productGamesystem.states = initialGenerationResult.states;
+      this.productGamesystem.transitions = initialGenerationResult.transitions
     }
+
+
+
+
   }
 
   private prepareChildsystemForGeneration(childsystem: Gamesystem<any, any>) {