diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.jav b/javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.java
similarity index 90%
rename from javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.jav
rename to javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.java
index 0972e76..3e0f0fe 100644
--- a/javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.jav
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.java
@@ -9,7 +9,11 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.assumptions.TypeInferenceInformation;
+
+import java.lang.System;
+import java.io.PrintStream;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.assumptions.TypeScopeContainer;
 
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.jav-back b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.jav-back
new file mode 100644
index 0000000..83f4fe8
--- /dev/null
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.jav-back
@@ -0,0 +1,81 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import java.lang.String;
+import java.lang.Boolean;
+import java.lang.Long;
+
+public class Constraint<A> extends HashSet<A> {
+	private static final Long serialVersionUID = 1L;
+	private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
+	private Boolean isImplemented = false;
+	
+	/*
+	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
+	 * auszuwaehlen 
+	 */
+	/*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
+	
+	private Constraint<A> extendConstraint = null;
+	
+	public Constraint() {
+		super();
+	}
+	
+	public Constraint( isInherited,  isImplemented) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+	}
+	
+	public Constraint(isInherited, isImplemented, extendConstraint, methodSignatureConstraint) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+		this.extendConstraint = extendConstraint;
+		this.methodSignatureConstraint = methodSignatureConstraint;
+	}
+	
+	public setIsInherited(isInherited) {
+		this.isInherited = isInherited;
+	}
+	
+	public isInherited() {
+		return isInherited;
+	}
+	
+	public isImplemented() {
+		return isImplemented;
+	}
+	
+	public getExtendConstraint() {
+		return extendConstraint;
+	}
+	
+	public setExtendConstraint(c) {
+		extendConstraint = c;
+	}
+	
+	public getmethodSignatureConstraint() {
+		return methodSignatureConstraint;
+	}
+	
+	public setmethodSignatureConstraint(c) {
+		methodSignatureConstraint = c;
+	}
+
+	public toString() {
+		return super.toString() + "\nisInherited = " + isInherited.toString() + " isOveridden = " + isImplemented.toString()
+				+ methodSignatureConstraint.toString() 
+				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
+				+ "\n" ;
+	}
+	
+	public toStringBase() {
+		return super.toString();
+	}
+	
+}
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java
index 1482189..be31fa0 100644
--- a/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java
@@ -31,7 +31,7 @@ public class ConstraintSet<A> {
         this.oderConstraints.addAll(allOderConstraints);
     }
     
-    public void addAll(ConstraintSet constraints) {
+    public void addAll(ConstraintSet<A> constraints) {
         this.addAllUndConstraint(constraints.undConstraints);
         this.addAllOderConstraint(constraints.oderConstraints);
     }
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Pair.jav-back b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Pair.jav-back
new file mode 100644
index 0000000..c8f12a6
--- /dev/null
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/constraints/Pair.jav-back
@@ -0,0 +1,161 @@
+package de.dhbwstuttgart.typeinference.constraints;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.SourceLoc;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.antlr.v4.runtime.Token;
+
+import java.lang.String;
+import java.lang.Boolean;
+import java.lang.NullPointerException;
+import java.lang.Object;
+import java.lang.Integer;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+
+public class Pair implements Serializable
+{
+    public final RefTypeOrTPHOrWildcardOrGeneric TA1;
+    public final RefTypeOrTPHOrWildcardOrGeneric TA2;
+
+    private SourceLoc location;
+
+    private PairOperator eOperator = PairOperator.SMALLER;
+    private Boolean noUnification = false;
+    
+
+    private Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 )
+    {
+        this.TA1 = TA1;
+        this.TA2 = TA2;
+        if(TA1 == null || TA2 == null)
+            throw new NullPointerException();
+        eOperator = PairOperator.SMALLER;
+    }
+
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp)
+    {
+        // Konstruktor
+        this(TA1,TA2);
+        this.eOperator = eOp;
+    }
+
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator e0p, SourceLoc location) {
+        this(TA1, TA2, e0p);
+        this.location = location;
+    }
+    
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, Boolean noUnification)
+    {
+        // Konstruktor
+        this(TA1,TA2);
+        this.eOperator = eOp;
+        this.noUnification = noUnification;
+    }
+
+    public SourceLoc getLocation() {
+        return this.location;
+    }
+    
+    public String toString()
+    {
+        // otth: Gibt ein Paar als String aus --> zum Debuggen und Vergleichen
+        String strElement1 = "NULL";
+        String strElement2 = "NULL";
+        String Operator = "<.";
+        
+        if( TA1 != null )
+             strElement1 = TA1.toString();
+    
+        if( TA2 != null )
+           strElement2 = TA2.toString();
+        
+       /* PL ausskommentiert 2018-05-24
+        if(OperatorEqual())
+        	Operator = "=";
+        if(OperatorSmaller())
+        	Operator = "<.";
+        if(OperatorSmallerExtends())
+        	Operator = "<?";
+        	*/
+        
+        return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
+        
+       /*- Equals: " + bEqual*/
+    }
+
+    /**
+     * <br/>Author: J�rg B�uerle
+     * @param obj
+     * @return
+     */
+    public boolean equals(Object obj)
+    {
+        boolean ret = true;
+        ret = ret & ((obj instanceof Pair) ? 1 : 0);
+        if(!ret)return ret;
+        ret = ret & (((Pair)obj).TA1.equals(this.TA1) ? 1 : 0);
+        ret = ret & (((Pair)obj).TA2.equals(this.TA2) ? 1 : 0);
+        return ret;
+    }
+
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ Equal ist.
+	*/
+    public boolean OperatorEqual()
+    {
+    	return eOperator == PairOperator.EQUALSDOT;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ Smaller ist.
+	*/
+    public boolean OperatorSmaller()
+    {
+    	return eOperator == PairOperator.SMALLER;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ SmallerExtends ist.
+	*/
+    public boolean OperatorSmallerExtends()
+    {
+    	return eOperator == PairOperator.SMALLERDOTWC;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Gibt den Operator zurück.
+	*/
+    public PairOperator GetOperator()
+    {
+    	return eOperator;
+    }
+
+    public boolean OperatorSmallerDot() {
+        return eOperator == PairOperator.SMALLERDOT;
+    }
+    
+    
+    static public Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
+        HashMap<String, TypePlaceholder> ret = new HashMap<>();
+        constraints.map((Pair p) -> {
+            if (p.TA1 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
+            }
+            if (p.TA2 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
+            }
+            return null;
+        });
+        return ret;
+    }
+}
+// ino.end
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.jav-back b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.jav-back
new file mode 100644
index 0000000..2d98221
--- /dev/null
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.jav-back
@@ -0,0 +1,115 @@
+package de.dhbwstuttgart.typeinference.typeAlgo;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+
+import de.dhbwstuttgart.util.BiRelation;
+
+import java.lang.Object;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Collection;
+import java.util.List;
+import java.util.AbstractSet;
+
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.ASTVisitor;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
+
+import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
+
+public class TYPE {
+
+    private final SourceFile sf;
+    private final Set<ClassOrInterface> allAvailableClasses;
+    
+    public TYPE(sf, allAvailableClasses){
+        this.sf = sf;
+        this.allAvailableClasses = allAvailableClasses;
+    }
+
+    public getConstraints() {
+        var ret = new ConstraintSet<>();
+        for ( cl : sf.KlassenVektor) {
+            var allClasses = new HashSet<>();
+            allClasses.addAll(allAvailableClasses);
+            allClasses.addAll(sf.availableClasses);
+            ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
+        }
+        return ret;
+    }
+
+    private getConstraintsClass(cl, info) {
+        var ret = new ConstraintSet<>();
+        var methConstrains;
+        for(m : cl.getMethods()){
+            methConstrains = getConstraintsMethod(m, info, cl);
+            ret.addAll(methConstrains);
+            m.constraints.addAll(methConstrains);
+        }
+        for(m : cl.getConstructors()){
+            ret.addAll(getConstraintsConstructor(m,info, cl));
+        }
+        if (cl.getfieldInitializations().isPresent()) {
+        	ret.addAll(getConstraintsConstructor(cl.getfieldInitializations().get(), info, cl));       	
+        }
+        if (cl.getStaticInitializer().isPresent())  {
+            ret.addAll(getConstraintsMethod(cl.getStaticInitializer().get(), info, cl));
+        }
+
+        return ret;
+    }
+    /*
+    TODO: Hier eine Information erstellen nur mit den importierte Klassen einer einzigen SourceFile
+        private TypeInferenceInformation getTypeInferenceInformation(sourceFile) {
+            DirectoryClassLoader classLoader = DirectoryClassLoader.getSystemClassLoader();
+            Set<ClassOrInterface> classes = new HashSet<>();
+
+            for(SourceFile sourceFile : sfs){
+                for(JavaClassName importName : sourceFile.imports){
+                    System.out.println(importName);
+                    try {
+                        classes.add(ASTFactory.createClass(classLoader.loadClass(importName.toString())));
+                    } catch (ClassNotFoundException e) {
+                        throw new DebugException("Klasse " + importName + " konnte nicht geladen werden");
+                    }
+                }
+                classes.addAll(sourceFile.KlassenVektor);
+            }
+
+            return new TypeInferenceInformation(classes);
+        }
+    */
+ 
+    private getConstraintsMethod(m, info, currentClass) {
+        if(m.block == null)return new ConstraintSet<>(); //Abstrakte Methoden generieren keine Constraints
+        var blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
+        var methodScope = new TYPEStmt(blockInfo);
+        m.block.accept(methodScope);
+        return methodScope.getConstraints();
+    }
+
+    private getConstraintsConstructor(m, info, currentClass) {
+        var blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
+        var methodScope = new TYPEStmt(blockInfo);
+        //for(Statement stmt : m.fieldInitializations)stmt.accept(methodScope);
+        var ret = this.getConstraintsMethod(m, info, currentClass);
+        ret.addAll(methodScope.getConstraints());
+        return ret;
+    }
+}
\ No newline at end of file
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java
index 8da1624..c763cfe 100644
--- a/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java
@@ -9,29 +9,9 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-
 import de.dhbwstuttgart.util.BiRelation;
 
-import java.lang.Object;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Collection;
-import java.util.List;
-import java.util.AbstractSet;
-
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
-import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-
-import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
+import java.util.*;
 
 public class TYPE {
 
@@ -111,4 +91,4 @@ public class TYPE {
         ret.addAll(methodScope.getConstraints());
         return ret;
     }
-}
\ No newline at end of file
+}
diff --git a/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
index be402d0..5ede3c3 100644
--- a/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/javatx-src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -2,7 +2,12 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import java.sql.Ref;
-import java.util.*;
+import java.util.List;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Stack;
+import java.util.Arrays;
+import java.util.ArrayList;
 import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -11,10 +16,59 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.*;
+
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.TypeScope;
+import de.dhbwstuttgart.syntaxtree.Pattern;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
-import de.dhbwstuttgart.syntaxtree.statement.*;
+
+import de.dhbwstuttgart.syntaxtree.statement.Assign;
+import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.statement.Switch;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.statement.CastExpr;
+import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
+import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
+import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
+import de.dhbwstuttgart.syntaxtree.statement.ForEachStmt;
+import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
+import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
+import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
+import de.dhbwstuttgart.syntaxtree.statement.NewArray;
+import de.dhbwstuttgart.syntaxtree.statement.NewClass;
+import de.dhbwstuttgart.syntaxtree.statement.ExpressionReceiver;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+import de.dhbwstuttgart.syntaxtree.statement.BoolExpression;
+import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.Throw;
+import de.dhbwstuttgart.syntaxtree.statement.Ternary;
+import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
+import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
+import de.dhbwstuttgart.syntaxtree.statement.Break;
+import de.dhbwstuttgart.syntaxtree.statement.This;
+import de.dhbwstuttgart.syntaxtree.statement.Super;
+import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
+import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
+import de.dhbwstuttgart.syntaxtree.statement.ThisCall;
+import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
+import de.dhbwstuttgart.syntaxtree.statement.SwitchBlock;
+import de.dhbwstuttgart.syntaxtree.statement.Yield;
+import de.dhbwstuttgart.syntaxtree.statement.SwitchLabel;
+
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;