diff --git a/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java b/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
index 5db79459..bfe353a1 100644
--- a/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
+++ b/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
@@ -240,8 +240,8 @@ public class ASTToTargetAST {
         );
     }
 
-    private final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
-    private final Set<Integer> usedFunNSuperTypes = new HashSet<>();
+    private static final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
+    private static final Set<Integer> usedFunNSuperTypes = new HashSet<>();
 
     public Map<String, byte[]> auxiliaries = new HashMap<>();
 
diff --git a/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java b/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
index 8c06b5d6..e966d29d 100644
--- a/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
+++ b/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
@@ -140,6 +140,7 @@ public abstract class GenerateGenerics {
         this.astToTargetAST = astToTargetAST;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
+                System.out.println(p.left + " " + p.left.getVariance());
                 simplifiedConstraints.add(new PairLT(new TPH(p.left), new TPH(p.right)));
             } else if (constraint instanceof PairTPHEqualTPH p) {
                 equality.put(p.getLeft(), p.getRight());
@@ -213,7 +214,8 @@ public abstract class GenerateGenerics {
                 equality.put(entry.getKey(), to);
             }
         }
-        to.setVariance(from.getVariance());
+        System.out.println(from + " -> " + to + " " + from.getVariance());
+        //from.setVariance(to.getVariance());
         equality.put(from, to);
         referenced.remove(new TPH(from));
         referenced.add(new TPH(to));
@@ -838,19 +840,24 @@ public abstract class GenerateGenerics {
         }
     }
 
-    TPH findConnectionToReturnType(Set<TPH> returnTypes, Set<Pair> input, Set<TPH> visited, TPH tph) {
+    Set<TPH> findConnectionToReturnType(Set<TPH> returnTypes, Set<Pair> input, Set<TPH> visited, TPH tph) {
         if (returnTypes.contains(tph)) {
-            return tph;
+            var res = new HashSet<TPH>();
+            res.add(tph);
+            return res;
         } else {
             for (var pair : input) if (pair instanceof PairLT ptph) {
                 if (ptph.left.equals(tph) && !visited.contains(ptph.right)) {
                     visited.add(ptph.right);
                     var result = findConnectionToReturnType(returnTypes, input, visited, ptph.right);
-                    if (result != null) return result;
+                    if (result.size() > 0) {
+                        result.add(ptph.right);
+                        return result;
+                    };
                 }
             }
         }
-        return null;
+        return new HashSet<>();
     }
 
     void eliminateInfimaConnectedToReturnType(Method method, Set<Pair> input, Set<TPH> referenced) {
@@ -867,19 +874,22 @@ public abstract class GenerateGenerics {
                     }
                 }
                 if (infima.size() > 1) {
+                    System.out.println(infima);
                     for (var pair : infima) {
                         var returnTypes = findTypeVariables(method.getReturnType());
-                        var returnType = findConnectionToReturnType(returnTypes, input, new HashSet<>(), pair.left);
-                        if (returnType != null && !returnType.equals(pair.left)) {
-                            System.out.println("Equals now: " + pair.left.resolve() + " " + returnType.resolve());
-                            addToEquality(pair.left.resolve(), returnType.resolve(), referenced);
+                        var chain = findConnectionToReturnType(returnTypes, input, new HashSet<>(), pair.left);
+                        System.out.println("Find: " + pair.left + " " + chain);
+                        chain.remove(pair.left);
+                        if (chain.size() > 0) {
+                            for (var tph : chain)
+                                addToEquality(pair.left.resolve(), tph.resolve(), referenced);
                             foundInfima = true;
                         }
                     }
                 }
             }
         } while (foundInfima);
-        input.removeIf((i) -> !(i instanceof PairLT lt) || lt.left.equals(lt.right));
+        input.removeIf((i) -> (i instanceof PairLT lt) && lt.left.equals(lt.right));
     }
 
     void eliminateInfima(Set<Pair> input, Set<TPH> referenced) {