diff --git a/resources/bytecode/javFiles/PairNoGenerics.jav b/resources/bytecode/javFiles/PairNoGenerics.jav
new file mode 100644
index 00000000..e69de29b
diff --git a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
index 1bcd7068..66bd713d 100644
--- a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
+++ b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
@@ -548,16 +548,13 @@ public class JavaTXCompiler {
 			SourceFile sf = sourceFiles.get(f);
 			allClasses.addAll(getAvailableClasses(sf));
 			allClasses.addAll(sf.getClasses());
-			var newClasses = CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).collect(Collectors.toList());
+			var newClasses = CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).toList();
 			for (var clazz : newClasses) {
-				var found = false;
-				for (var old : allClasses) {
-					if (clazz.getClassName().equals(old.getClassName())) {
-						found = true;
-						break;
-					}
-				}
-				if (!found) allClasses.add(clazz);
+				// Don't load classes that get recompiled
+				if (sf.getClasses().stream().anyMatch(nf -> nf.getClassName().equals(clazz.getClassName())))
+					continue;
+				if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
+					allClasses.add(clazz);
 			}
 		}
 
diff --git a/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java b/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
index 5db79459..639bdfd0 100644
--- a/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
+++ b/src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java
@@ -295,7 +295,9 @@ public class ASTToTargetAST {
                         try {
                             classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
-                            classLoader.loadClass(code);
+                            try {
+                                classLoader.loadClass(code);
+                            } catch (LinkageError ignored) {}
                         }
                         auxiliaries.put(superClassName, code);
                     }
@@ -306,7 +308,9 @@ public class ASTToTargetAST {
                         try {
                             classLoader.findClass(className);
                         } catch (ClassNotFoundException e) {
-                            classLoader.loadClass(code);
+                            try {
+                                classLoader.loadClass(code);
+                            } catch (LinkageError ignored) {}
                         }
                         usedFunN.put(className, gep);
                         auxiliaries.put(className, code);
diff --git a/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java b/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
index 8c06b5d6..2f437d6e 100644
--- a/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
+++ b/src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java
@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import com.google.common.collect.Streams;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
@@ -18,6 +19,8 @@ import de.dhbwstuttgart.util.Pair;
 
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 public abstract class GenerateGenerics {
 
@@ -140,10 +143,12 @@ 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());
             } else if (constraint instanceof PairTPHequalRefTypeOrWildcardType p) {
+                System.out.println(p.left + " = " + p.right);
                 concreteTypes.put(new TPH(p.left), p.right);
             }
         }
@@ -213,7 +218,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));
@@ -759,14 +765,14 @@ public abstract class GenerateGenerics {
             oldFamily.clear();
             oldFamily.putAll(familyOfMethods);
             familyOfMethods.clear();
-            for (var method : classOrInterface.getMethods()) {
+            Stream.concat(classOrInterface.getMethods().stream(), classOrInterface.getConstructors().stream()).forEach(method -> {
                 family(classOrInterface, method);
-            }
+            });
         } while(!oldFamily.equals(familyOfMethods));
 
-        for (var method : classOrInterface.getMethods()) {
+        Stream.concat(classOrInterface.getMethods().stream(), classOrInterface.getConstructors().stream()).forEach(method -> {
             generics(classOrInterface, method);
-        }
+        });
     }
 
     private void findChain(Set<TPH> referenced, Set<Pair> input, Set<Pair> output, TPH start, TPH end, Set<TPH> chain) {
@@ -838,19 +844,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 +878,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) {