Merge branch 'plugin' of ssh://gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into plugin

2018-09-10 02:37:12 +02:00 · 2018-09-10 02:37:12 +02:00 · 4e939a6131
commit 4e939a6131
parent ac49f26df3 3fedbcc4a0
87 changed files with 1695 additions and 298 deletions
--- a/Website/JavaTXExamples.zip
+++ b/Website/JavaTXExamples.zip
--- a/Website/index.html
+++ b/Website/index.html
@ -0,0 +1,88 @@
 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html> <head>
 <title>Java-TX Plugin</title></head>
 <center>
 <h1>Java-TX Plugin</h1>
 </center>
 <h2>Content</h2>
 <ul>
  <li><h4><a href="#introduction">Introduction</a></h4></li>
  <li><h4><a href="newJavaTXProject/newJavaTXProject.html" >New Java-TX project</a></h4></li>
  <li><h4><a href=" JavaTXExamples.zip" >Example project</a></h4></li>
  <li><a href="usePlugin/usePlugin.html" >Using the plugin</a></li>
  <li><h4><a href="install/install.html" >Installation</a></h4>
 </li>
 </ul>
 <br/>
 <h2 id="introduction">Introduction</h2>
 Java-TX (Java Type eXtended) is an extension of Java in which a global type inference algorithm and real function types are added. Since the end of the nineties features from functional program- ming languages have been transferred to Java. Parametric polymorphism extended by wildcards, called generics, were transfered to Java 5.0. Higher-order functions and lambda expression were introduced in Java 8. Java 8 uses functional interfaces as target types of lambda expressions in contrast to real function types as in functional programming languages.
 The powerful feature type inference from functional programming languages is incorporated into Java, as into other object-oriented
 languages, i.e. only in a restricted way called local type inference. Local type inference allows certain type annotations to be omitted. For instance, it is often not necessary to specify the type of a variable. Type parameters of classes in the new-statement can be left out. Return types of methods can often also be omitted. Local type inference is at its most pronounced in Scala. In Java 10 an extention of local type inference is introduced, where types of local variables can be replaced by the keyword var and inferred automatically during the compilation. In contrast to global type inference, local type inference allows types of recursive methods and lambda expressions not to be omitted.<br>
 The Java-TX project contributes to the design of object-oriented languages by developing global type inference algorithms for Java-like languages.
 <h3>First Example</h3>
 The class <tt>Id</tt> has the method <tt>id</tt>. The type annotations are omitted.
 <br/>
 <pre> <code class="language-java">
  class Id {
      id(x) {
          return x;
      }
  } 
 </code> </pre>
 The type inference algorithm inferrs the types, such that <tt>Id</tt> can be applied:
 <pre>
    new Id().id(1);
    new Id().id("hallo");
 </pre>
 <h3>More complex example</h3>
 <pre>
  import java.lang.Integer;
  import java.lang.Double; 
  import java.lang.String; 
  class OL {
     m(x) { return x + x; }
  }
  class OLMain {
     main(x) { 
 	var ol;
 	ol = new OL(); 
 	return ol.m(x); 
     }  
  }
 </pre>
 The type inference mechanism considers only imported types. Therefore  <tt>Integer</tt> <tt>Double</tt>, and <tt>String</tt> are imported.
 <br/>
 As the operator <tt>+</tt> is overloaded by all numeric types and String the methods  <tt>m</tt> in  the class <tt>OL</tt> and <tt>main</tt> in the class <tt>OLMain</tt>, respectively, gets all these types. The generated classfile demonstrates this:
 <pre>
 > javap OL.class 
 Compiled from "OL.jav"
 class OL {
  public OL();
  public java.lang.Integer m(java.lang.Integer);
  public java.lang.Double m(java.lang.Double);
 }
 > javap OLMain.class 
 Compiled from "OLMain.jav"
 class OLMain {
  public OLMain();
  public java.lang.Integer main(java.lang.Integer);
  public java.lang.Double main(java.lang.Double);
 }
 </pre>
 <hr>
 <address></address>
 <!-- hhmts start -->Last modified: Fri Jun  1 16:43:55 CEST 2018 <!-- hhmts end -->
 </body> </html>
--- a/Website/install/Restart.png
+++ b/Website/install/Restart.png
--- a/Website/install/availableSoftware1.png
+++ b/Website/install/availableSoftware1.png
--- a/Website/install/availableSoftware2.png
+++ b/Website/install/availableSoftware2.png
--- a/Website/install/instal.html
+++ b/Website/install/instal.html
@ -0,0 +1,40 @@
 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html> <head>
 <title>Install Java-TX Plugin</title>
 </head>
 <body>
 <h1>Install Java-TX Plugin</h1>
 <ol>
  <li>Select "Install New Software ..."<br>
  <img width= 400 src="newsoftware.png" >
  </li>
  <li>Add ...<br>
  <img width=550 src="availableSoftware1.png" >
  </li>
  <li>Insert address<br>
  <img width=550 src="availableSoftware2.png" >
  </li>
  <li>Select installation<br>
  <img width=550 src="selectInstallation.png" >
  </li>
  <li>Installation details<br>
  <img width=550 src="installationDetails.png" >
  </li>
  <li>Accept license agreement<br>
  <img width=550 src="licenseAgreement.png" >
  </li>
  <li>Install anyway<br>
  <img width=450 src="installAnyway.png">
  </li>
  <li>Restart<br>
  <img width=450 src="Restart.png">
  </li>
 </ol>
 <hr>
 <address></address>
 <!-- hhmts start -->Last modified: Fri Jun  1 11:57:15 CEST 2018 <!-- hhmts end -->
 </body> </html>
--- a/Website/install/install.html
+++ b/Website/install/install.html
@ -0,0 +1,40 @@
 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html> <head>
 <title>Install Java-TX Plugin</title>
 </head>
 <body>
 <h2>Install Java-TX Plugin</h2>
 <ol>
  <li>Select "Install New Software ..."<br>
  <img width= 400 src="newsoftware.png" >
  </li>
  <li>Add ...<br>
  <img width=550 src="availableSoftware1.png" >
  </li>
  <li>Insert address<br>
  <img width=550 src="availableSoftware2.png" >
  </li>
  <li>Select installation<br>
  <img width=550 src="selectInstallation.png" >
  </li>
  <li>Installation details<br>
  <img width=550 src="installationDetails.png" >
  </li>
  <li>Accept license agreement<br>
  <img width=550 src="licenseAgreement.png" >
  </li>
  <li>Install anyway<br>
  <img width=450 src="installAnyway.png">
  </li>
  <li>Restart<br>
  <img width=450 src="Restart.png">
  </li>
 </ol>
 <hr>
 <address></address>
 <!-- hhmts start -->Last modified: Fri Jun  1 12:05:43 CEST 2018 <!-- hhmts end -->
 </body> </html>
--- a/Website/install/installAnyway.png
+++ b/Website/install/installAnyway.png
--- a/Website/install/installationDetails.png
+++ b/Website/install/installationDetails.png
--- a/Website/install/licenseAgreement.png
+++ b/Website/install/licenseAgreement.png
--- a/Website/install/newsoftware.png
+++ b/Website/install/newsoftware.png
--- a/Website/install/selectInstallation.png
+++ b/Website/install/selectInstallation.png
--- a/Website/newJavaTXProject/addLibrary2.png
+++ b/Website/newJavaTXProject/addLibrary2.png
--- a/Website/newJavaTXProject/buildPath1.png
+++ b/Website/newJavaTXProject/buildPath1.png
--- a/Website/newJavaTXProject/buildPath2.png
+++ b/Website/newJavaTXProject/buildPath2.png
--- a/Website/newJavaTXProject/buildPath3.png
+++ b/Website/newJavaTXProject/buildPath3.png
--- a/Website/newJavaTXProject/buildPath4.png
+++ b/Website/newJavaTXProject/buildPath4.png
--- a/Website/newJavaTXProject/newJavFile.png
+++ b/Website/newJavaTXProject/newJavFile.png
--- a/Website/newJavaTXProject/newJavFolder1.png
+++ b/Website/newJavaTXProject/newJavFolder1.png
--- a/Website/newJavaTXProject/newJavFolder2.png
+++ b/Website/newJavaTXProject/newJavFolder2.png
--- a/Website/newJavaTXProject/newJavaTXProject.html
+++ b/Website/newJavaTXProject/newJavaTXProject.html
@ -0,0 +1,34 @@
 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html> <head>
 <title></title>
 </head>
 <h2>New Java-TX project in eclipse</h2>
 <ol>
  <li>New -> Java Project<br/>
  <img  width= 400 src="newJavaTXProject.png" >
  </li>
  <br/>
  <li>Generate a jav-File folder<br/>
  <img  width= 550 src="newJavFolder1.png" ><br/><br/>
  <img  width= 550 src="newJavFolder2.png" >
  </li>
  <br/>
  <li>Add jav-File folder as library<br/>
  At the moment no package system is implemented, Therefore the compiled class files are in the jav-File folder. This has to be added as library:<br/>
  <img  width= 550 src="buildPath1.png" ><br/><br/>
  <img  width= 550 src="buildPath2.png" ><br/><br/>
  <img  width= 400 src="buildPath3.png" ><br/><br/>
  <img  width= 550 src="buildPath4.png" ><br/>
  </li>
 </ol>
 <body>
 <h1></h1>
 <hr>
 <address></address>
 <!-- hhmts start -->Last modified: Fri Jun  1 16:50:02 CEST 2018 <!-- hhmts end -->
 </body> </html>
--- a/Website/newJavaTXProject/newJavaTXProject.png
+++ b/Website/newJavaTXProject/newJavaTXProject.png
--- a/Website/usePlugin/usePlugin.html
+++ b/Website/usePlugin/usePlugin.html
@ -0,0 +1,24 @@
 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
 <html> <head>
 <title>Using the plugin</title>
 </head>
 <h2>Using the plugin</h2>
 <ol>
  <li>Overview<br/>
  <img  width=800 src="usePlugin1.png" >
  </li>
  <br/>
  <li>Select types<br/>
  If the method is overloaded the user can select types in the outline the right mouse button:<br/><br/>
  <img src="usePlugin2.png" ><br/>
  </li>
 </ol>
 <body>
 <h1></h1>
 <hr>
 <address></address>
 <!-- hhmts start -->Last modified: Fri Jun  1 16:51:28 CEST 2018 <!-- hhmts end -->
 </body> </html>
--- a/Website/usePlugin/usePlugin1.png
+++ b/Website/usePlugin/usePlugin1.png
--- a/Website/usePlugin/usePlugin2.png
+++ b/Website/usePlugin/usePlugin2.png
--- a/doc/PluginBau.pdf
+++ b/doc/PluginBau.pdf
--- a/src/de/dhbwstuttgart/.DS_Store
+++ b/src/de/dhbwstuttgart/.DS_Store
--- a/src/de/dhbwstuttgart/bytecode/ArgumentVisitor.java
+++ b/src/de/dhbwstuttgart/bytecode/ArgumentVisitor.java
@ -0,0 +1,255 @@
 package de.dhbwstuttgart.bytecode;
 import java.util.List;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
 import de.dhbwstuttgart.syntaxtree.statement.Assign;
 import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
 import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.CastExpr;
 import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
 import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
 import de.dhbwstuttgart.syntaxtree.statement.ExpressionReceiver;
 import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
 import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
 import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
 import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.statement.Literal;
 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.Return;
 import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
 import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
 import de.dhbwstuttgart.syntaxtree.statement.Super;
 import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
 import de.dhbwstuttgart.syntaxtree.statement.This;
 import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr;
 import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
 public class ArgumentVisitor implements StatementVisitor {
 	private List<Boolean> argListMethCall;
 	private BytecodeGenMethod bytecodeGenMethod;
 	public ArgumentVisitor(List<Boolean> argListMethCall, BytecodeGenMethod bytecodeGenMethod) {
 		this.argListMethCall = argListMethCall;
 		this.bytecodeGenMethod = bytecodeGenMethod;
 	}
 	@Override
 	public void visit(ArgumentList argumentList) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
 		lambdaExpression.accept(bytecodeGenMethod);
 		// Zieltype des Lambas ist Funktionale Interface
 		// kann nie primitiv sein => un-/boxing wird hier nicht gebraucht
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(Assign assign) {
 		assign.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(assign.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(BinaryExpr binary) {
 		binary.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(binary.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(Block block) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(CastExpr castExpr) {
 		castExpr.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(castExpr.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(EmptyStmt emptyStmt) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(FieldVar fieldVar) {
 		fieldVar.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(fieldVar.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(ForStmt forStmt) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(IfStmt ifStmt) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(InstanceOf instanceOf) {
 		instanceOf.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(instanceOf.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(LocalVar localVar) {
 		localVar.accept(bytecodeGenMethod);
 		if(!bytecodeGenMethod.isBinaryExp) {
 			if(argListMethCall.get(0))
 				bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(localVar.getType()));
 		}
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(LocalVarDecl localVarDecl) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(MethodCall methodCall) {
 		methodCall.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(NewClass methodCall) {
 		methodCall.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(NewArray newArray) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(Return aReturn) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(ReturnVoid aReturn) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(StaticClassName staticClassName) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(Super aSuper) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(This aThis) {
 		aThis.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(aThis.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(WhileStmt whileStmt) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(DoStmt whileStmt) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(AssignToField assignLeftSide) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(AssignToLocal assignLeftSide) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(SuperCall superCall) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(ExpressionReceiver expressionReceiver) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(UnaryExpr unaryExpr) {
 		unaryExpr.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(unaryExpr.getType()));
 		argListMethCall.remove(0);
 	}
 	@Override
 	public void visit(Literal literal) {
 		literal.accept(bytecodeGenMethod);
 		if(argListMethCall.get(0))
 			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(literal.getType()));
 		argListMethCall.remove(0);
 	}
 }
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
@ -16,7 +16,9 @@ import org.objectweb.asm.Type;
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.signature.TypeToString;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
 import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
@ -28,6 +30,8 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 import de.dhbwstuttgart.typeinference.result.ResolvedType;
 import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@ -41,8 +45,13 @@ public class BytecodeGen implements ASTVisitor {
 	private boolean isInterface;
 	private List<ResultSet> listOfResultSets;
 	private ResultSet resultSet;
 	private SourceFile sf;
 	private String path;
 	private int indexOfFirstParam = 0;
 	private String superClass;
 	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
 	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
 	// stores generics and their bounds of class
@ -50,22 +59,27 @@ public class BytecodeGen implements ASTVisitor {
 	// stores generics and their bounds of method
 	HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
 	private final TPHExtractor tphExtractor = new TPHExtractor();
 	private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
 	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
 	HashMap<String,byte[]> classFiles;
 	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
-	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets) {
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets,SourceFile sf ,String path) {
 		this.classFiles = classFiles;
 		this.listOfResultSets = listOfResultSets;
 		this.sf = sf;
 		this.path = path;
 	}
 	@Override
 	public void visit(SourceFile sourceFile) {
 		for(ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
-			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets);
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, sf, path);
 			cl.accept(classGen);
 			classGen.writeClass(cl.getClassName().toString());
 		}
@ -90,6 +104,7 @@ public class BytecodeGen implements ASTVisitor {
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
 		className = classOrInterface.getClassName().toString();
 		cw.visitSource(className +".jav", null);
@ -97,27 +112,41 @@ public class BytecodeGen implements ASTVisitor {
 		isInterface = (classOrInterface.getModifiers()&512)==512;
 		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
 		String sig = null;
 		/* if class has generics then creates signature
 		 * Signature looks like:
 		 * <E:Ljava/...>Superclass 
 		 */
 		if(classOrInterface.getGenerics().iterator().hasNext()) {
 			Signature signature = new Signature(classOrInterface, genericsAndBounds);
 			sig = signature.toString();
 		}
 		// needs implemented Interfaces?
 		cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
 				, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
-		for(Field f : classOrInterface.getFieldDecl()) {
+		
 			f.accept(this);
 		}
 //		resultSet = listOfResultSets.get(0);
 		boolean isConsWithNoParamsVisited = false;
 		boolean isVisited = false;
 		for(ResultSet rs : listOfResultSets) {
 			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
 			resultSet = rs;
 			// Nur einmal ausführen!!
 			if(!isVisited) {
 				classOrInterface.accept(tphExtractor);
 				getCommonTPHS(tphExtractor);
 				String sig = null;
 				/* if class has generics then creates signature
 				 * Signature looks like:
 				 * <E:Ljava/...>Superclass 
 				 */
 				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty()) {
 					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
 					sig = signature.toString();
 					System.out.println("Signature: => " + sig);
 				}
 				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
 						, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
 				isVisited = true;
 			}
 			for(Field f : classOrInterface.getFieldDecl()) {
 				f.accept(this);
 			}
 			for(Constructor c : classOrInterface.getConstructors()) {
 				if(!isConsWithNoParamsVisited)
 					c.accept(this);
@ -133,6 +162,16 @@ public class BytecodeGen implements ASTVisitor {
 	}
 	private void getCommonTPHS(TPHExtractor tphExtractor) {
 		// Gemeinsame TPHs
 		ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
 		// Alle TPHs der Felder speichern
 		for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
 			if(!tphExtractor.allTPHS.get(tph))
 				cTPHs.add(tph);
 		}
 	}
 	@Override
 	public void visit(Constructor field) {
 		field.getParameterList().accept(this);
@ -141,23 +180,25 @@ public class BytecodeGen implements ASTVisitor {
 		boolean hasGen = false;
 		for(String paramName : methodParamsAndTypes.keySet()) {
-			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
-			if(genericsAndBounds.containsKey(typeOfParam)) {
+			if(genericsAndBounds.containsKey(typeOfParam) ||typeOfParam.substring(0, 4).equals("TPH ")
 					|| typeOfParam.contains("<")) {
 				hasGen = true;
 				break;
 			}
 		}
 		String sig = null;
 		if(hasGen) {
-			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes);
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(field.name,tphExtractor.allPairs);
 			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes,resultSet,pairs);
 			sig = signature.toString();
 		}
 		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
 		desc = constructor.accept(new DescriptorToString(resultSet));
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
 		mv.visitCode();		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,field, mv,paramsAndLocals,cw,
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		if(!field.getParameterList().iterator().hasNext()) {
 			mv.visitInsn(Opcodes.RETURN);
 		}
@ -215,11 +256,14 @@ public class BytecodeGen implements ASTVisitor {
 		/* if method has generics or return type is TPH, create signature */
 		// zwite operand muss weggelassen werden
 		if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
-			// resultset hier zum testen 
+			
-			Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
 			System.out.println(method.name + " => Simplified Pairs: ");
 			pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
 			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet, pairs);
 			sig = signature.toString();
 		}
-//		System.out.println(sig);
+		System.out.println(method.getName()+" ==> "+sig);
 		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
 		methDesc = meth.accept(new DescriptorToString(resultSet));
@ -227,13 +271,103 @@ public class BytecodeGen implements ASTVisitor {
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
 		mv.visitCode();		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,method, mv,paramsAndLocals,cw,
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
 	private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
 		allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
 		if(allPairs.size() < 2)
 			return allPairs;
 		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
 		MethodAndTPH method;
 		ArrayList<TypePlaceholder> methodTphs = new ArrayList<>();
 		ArrayList<GenericInsertPair> methodPairs = new ArrayList<>();
 		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
 			if(m.getName().equals(methodName)) {
 				methodTphs = m.getTphs();
 				methodPairs = m.getPairs();
 				break;
 			}
 		}
 		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
 		for(GenericInsertPair p : allPairs) {
 			// Tph2.jav
 			if(subAndSuperTph.containsKey(p.TA1)) {
 				if(methodTphs.contains(subAndSuperTph.get(p.TA1)))
 					continue;
 			}
 			subAndSuperTph.put(p.TA1, p.TA2);
 		}
 		int numOfVisitedPairs = 0;
 		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
 			if(numOfVisitedPairs>=subAndSuperTph.size())
 				break;
 			if(!methodTphs.contains(subTph))
 				continue;
 			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
 			tphsInRel.put(tphsInRel.size(), subTph);
 			TypePlaceholder superTph = subAndSuperTph.get(subTph);
 			tphsInRel.put(tphsInRel.size(), superTph);
 			numOfVisitedPairs++;
 			while(subAndSuperTph.containsKey(superTph)) {
 				superTph = subAndSuperTph.get(superTph);
 				tphsInRel.put(tphsInRel.size(), superTph);
 				numOfVisitedPairs++;
 			}
 			// Subtype
 			TypePlaceholder subTphRes = tphsInRel.get(0);
 			// Die größte Supertype
 			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
 			while(subAndSuperTph.containsValue(subTphRes)) {
 				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
 					if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
 						subTphRes = tph;
 						break;
 					}
 				}
 				if(subTphRes.equals(tphsInRel.get(0))) {
 					break;
 				}
 				tphsInRel.put(0, subTphRes);
 				numOfVisitedPairs++;
 			}
 			subTphRes = tphsInRel.get(0);
 			int i = 2;
 			while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
 				superTphRes = tphsInRel.get(tphsInRel.size()-i);
 				i++;
 			}
 			// teste noch den Fall X < Y und Y nicht in TPHS der Methode
 			// 		 Dann hat man nach der While-Schleife X < Y
 			//		 Y muss durch Object ersetzt.
 			// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen) 
 			if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
 				GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
 				simplifiedPairs.add(sPair);
 			}
 		}
 		return simplifiedPairs;
 	}
 	@Override
 	public void visit(ParameterList formalParameters) {
 		paramsAndLocals = new HashMap<>();
@ -475,5 +609,50 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(UnaryExpr unaryExpr) {
 		throw new NotImplementedException();
 	}
 	private class TPHExtractor extends AbstractASTWalker{
 		// Alle TPHs der Felder werden iKopf der Klasse definiert
 		// alle TPHs der Klasse: (TPH, is in Method?)
 		final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
 		MethodAndTPH methodAndTph;
 		Boolean inMethod = false;
 		final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
 		final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
 		@Override
 		public void visit(TypePlaceholder tph) {
 			if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
 				TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
 				if(inMethod)
 					methodAndTph.getTphs().add(resolvedTPH);
 				allTPHS.put(resolvedTPH,inMethod);
 				resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
 					if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
 						if(inMethod)
 							methodAndTph.getPairs().add(ag);
 						allPairs.add(ag);
 					}
 				});
 			}
 		}
 		private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
 			for(int i=0; i<pairs.size();++i) {
 				GenericInsertPair p = pairs.get(i);
 				if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
 					return true;
 			}
 			return false;
 		}
 		@Override
 		public void visit(Method method) {
 			inMethod = true;
 			methodAndTph = new MethodAndTPH(method.name);
 			super.visit(method);
 			inMethod = false;
 			ListOfMethodsAndTph.add(methodAndTph);
 		}
 	}
 }
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
@ -8,9 +8,14 @@ import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.reflect.Parameter;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@ -29,15 +34,21 @@ import org.objectweb.asm.signature.SignatureWriter;
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.utilities.KindOfLambda;
 import de.dhbwstuttgart.bytecode.utilities.Lambda;
 import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
 import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 public class BytecodeGenMethod implements StatementVisitor {
@ -50,12 +61,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 	private ClassWriter cw;
 	private ResultSet resultSet;
 	private boolean isInterface;
-	HashMap<String, String> genericsAndBoundsMethod;
+	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String, String> genericsAndBounds;
-	private boolean isBinaryExp = false;
+	public boolean isBinaryExp = false;
-
+	private String superClass;
 	private String path;
 	private SourceFile sf;
 	private IStatement statement = null;
-
+	
 //	private int numMethodCalls = 0;
 	// for tests **
 	private String fieldName;
 	private String fieldDesc;
@ -67,11 +82,12 @@ public class BytecodeGenMethod implements StatementVisitor {
 	private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();;
-	public BytecodeGenMethod(String className, ResultSet resultSet, Method m, MethodVisitor mv,
+	public BytecodeGenMethod(String className, String superClass,ResultSet resultSet, Method m, MethodVisitor mv,
 			HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles) {
+			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles, SourceFile sf,String path) {
 		this.className = className;
 		this.superClass = superClass;
 		this.resultSet = resultSet;
 		this.m = m;
 		this.mv = mv;
@ -81,19 +97,22 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.genericsAndBounds = genericsAndBounds;
 		this.isInterface = isInterface;
 		this.classFiles = classFiles;
-
+		this.sf = sf;
 		this.path = path;
 		if (!isInterface)
 			this.m.block.accept(this);
 	}
 	public BytecodeGenMethod(LambdaExpression lambdaExpression, ResultSet resultSet, MethodVisitor mv,
-			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles) {
+			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path) {
 		this.resultSet = resultSet;
 		this.mv = mv;
 		this.isInterface = isInterface;
 		this.classFiles = classFiles;
 		this.path = path;
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
 		int i = indexOfFirstParamLam;
@ -104,8 +123,12 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 		lambdaExpression.methodBody.accept(this);
 	}
-
+	
-	private String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
+	public void isBinary(boolean isBinary) {
 		this.isBinaryExp =isBinary;
 	}
 	public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
 		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
 	}
@ -113,6 +136,11 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(Block block) {
 		for (Statement stmt : block.getStatements()) {
 			stmt.accept(this);
 			if(stmt instanceof MethodCall) {
 				String ret = getResolvedType(((MethodCall) stmt).getType());
 				if(!ret.equals("void"))
 					mv.visitInsn(Opcodes.POP);
 			}
 		}
 	}
@ -120,7 +148,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(SuperCall superCall) {
 		superCall.receiver.accept(this);
 		superCall.arglist.accept(this);
-		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Object.class), superCall.name, "()V",
+		mv.visitMethodInsn(Opcodes.INVOKESPECIAL, this.superClass, superCall.name, "()V",
 				isInterface);
 	}
@ -129,7 +157,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(LocalVar localVar) {
 		// wenn String + String zuerst wird ein StringBuilder initialisiert dann
 		// wird die lokale Var geladen. Sonst wird zuerst die lokale Var geladen.
-
+		System.out.println(localVar.name);
 		mv.visitVarInsn(Opcodes.ALOAD, paramsAndLocals.get(localVar.name));
 		if (isBinaryExp) {
@ -167,6 +195,11 @@ public class BytecodeGenMethod implements StatementVisitor {
 			doBoxing(binaryType);
 			isBinaryExp = false;
 		}
 		System.out.println("ASSIGN TYPE R: " + getResolvedType(assign.rightSide.getType()));
 		String typeOfRightSide = getResolvedType(assign.rightSide.getType());
 		if(typeOfRightSide.contains("<")) {
 			mv.visitTypeInsn(Opcodes.CHECKCAST, typeOfRightSide.substring(0, typeOfRightSide.indexOf('<')));
 		}
 		assign.lefSide.accept(this);
 		statement = null;
@ -180,7 +213,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		String largerType = getLargerType(lexpType, rexpType);
 		String typeOfBinary = getResolvedType(binary.getType());
-
+		
 		if (typeOfBinary.equals(Type.getInternalName(String.class))) {
 			mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(StringBuilder.class));
 			mv.visitInsn(Opcodes.DUP);
@ -520,7 +553,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 				methodName, arg3.toString(), null, null);
 		new BytecodeGenMethod(lambdaExpression, this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface,
-				classFiles);
+				classFiles,this.path);
 		mvLambdaBody.visitMaxs(0, 0);
 		mvLambdaBody.visitEnd();
@ -561,7 +594,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		try {
 			System.out.println("generating " + name + ".class file...");
 			output = new FileOutputStream(
-					new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" + name + ".class"));
+					new File(path + name + ".class"));
 			output.write(bytecode);
 			output.close();
 			System.out.println(name + ".class file generated");
@ -575,7 +608,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 	@Override
 	public void visit(CastExpr castExpr) {
 		// TODO Auto-generated method stub
 	}
@ -587,7 +619,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 	@Override
 	public void visit(FieldVar fieldVar) {
 		fieldName = fieldVar.fieldVarName;
 		fieldDesc = "L" + getResolvedType(fieldVar.getType()) + ";";
@ -615,32 +646,157 @@ public class BytecodeGenMethod implements StatementVisitor {
 	@Override
 	public void visit(InstanceOf instanceOf) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void visit(MethodCall methodCall) {
-
+		System.out.println("In MethodCall = " + methodCall.name);
 		String receiverName = getResolvedType(methodCall.receiver.getType());
 		System.out.println("Methods of " + receiverName + " ");
 		ClassLoader cLoader = ClassLoader.getSystemClassLoader();
 		java.lang.reflect.Method methodRefl = null;
 		String clazz = receiverName.replace("/", ".");
 		try {
 			if(receiverName.contains("<")) {
 				clazz = clazz.substring(0, receiverName.indexOf("<"));
 			}
 			java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
 			System.out.println("Methods of " + receiverName + " ");
 			for(java.lang.reflect.Method m : methods) {
 				if(methodCall.name.equals(m.getName())) {
 					methodRefl = m;
 					break;
 				}
 			}
 		} catch (Exception e) {
 			String superClass = "";
 			// TODO: Test SubMatrix.jav
 			while(true) {
 				for(ClassOrInterface cl : sf.getClasses()) {
 					if(receiverName.equals(cl.getClassName().toString())) {
 						superClass = cl.getSuperClass().getName().toString();
 						break;
 					}
 				}
 				System.out.println(superClass);
 				if(superClass.equals(""))
 					break;
 				try {
 					String superClazz = superClass.replace("/", ".");
 					if(superClass.contains("<")) {
 						superClazz = superClazz.substring(0, superClass.indexOf("<"));
 					}
 					java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
 					System.out.println("Methods of " + superClass + " ");
 					for(java.lang.reflect.Method m : methods) {
 						if(methodCall.name.equals(m.getName())) {
 							methodRefl = m;
 							break;
 						}
 					}
 					break;
 				} catch (Exception e2) {
 					receiverName = superClass;
 					continue;
 				}
 			}
 		}
 		methodCall.receiver.accept(this);
-		methodCall.arglist.accept(this);
+		
-
+		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
-		MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
+		String mDesc = "";
-				genericsAndBoundsMethod, genericsAndBounds);
+		List<Boolean> argListMethCall = new LinkedList<>();
-		String mDesc = method.accept(new DescriptorToString(resultSet));
+		if(methodRefl == null) {
-
+			MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
 					receiverName, genericsAndBoundsMethod, genericsAndBounds);
 			mDesc = method.accept(new DescriptorToString(resultSet));
 			methodCall.arglist.accept(this);
 		} else {
 			for(Parameter p:methodRefl.getParameters()) {
 				System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive());
 				argListMethCall.add(p.getType().isPrimitive());
 			}
 			mDesc = getMethodDesc(methodRefl);
 			for (Expression al : methodCall.arglist.getArguments()) {
 				statement = new ArgumentExpr(al);
 				ArgumentVisitor argV = new ArgumentVisitor(argListMethCall,this); 
 				al.accept(argV);
 				statement = null;
 			}
 		}
 		System.out.println("Methodcall Desc : " + mDesc);
 //		methodCall.arglist.accept(this);
 		// is methodCall.receiver functional Interface)?
 		if (varsFunInterface.contains(methodCall.receiver.getType())) {
-			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), methodCall.name,
+			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, clazz.replace(".", "/"), methodCall.name,
-					mDesc, false);
+					mDesc, true);
 		} else {
-			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, getResolvedType(methodCall.receiver.getType()), methodCall.name,
+			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, clazz.replace(".", "/"), methodCall.name,
 					mDesc, isInterface);
 		}
-		// test
+
-		// if(!methodCall.getType().toString().equals("V")) {
+		if(methodRefl != null && !methodRefl.getReturnType().isPrimitive()) {
-		// mv.visitInsn(Opcodes.POP);
+			if(methodRefl.getReturnType().equals(Object.class)) {
-		// }
+				String checkCast = getResolvedType(methodCall.getType());
 				int pos = checkCast.length();
 				if(checkCast.contains("<"))
 					pos = checkCast.indexOf("<");
 				mv.visitTypeInsn(Opcodes.CHECKCAST,checkCast.substring(0,pos));
 			}
 			if(isBinaryExp)
 				doUnboxing(getResolvedType(methodCall.getType()));
 		}
 	}
 	private String getMethodDesc(java.lang.reflect.Method methodRefl) {
 		StringBuilder sb = new StringBuilder("(");
 		for(final Class c:(methodRefl.getParameterTypes()))
 	        sb= sb.append(getDescriptorForClass(c));
 	    sb.append(')');
 	    sb.append(getDescriptorForClass(methodRefl.getReturnType()));
 	    return sb.toString();
 	}
 	private String getDescriptorForClass(final Class c) {
 		if(c.isPrimitive())
 	    {
 	        if(c==byte.class)
 	            return "B";
 	        if(c==char.class)
 	            return "C";
 	        if(c==double.class)
 	            return "D";
 	        if(c==float.class)
 	            return "F";
 	        if(c==int.class)
 	            return "I";
 	        if(c==long.class)
 	            return "J";
 	        if(c==short.class)
 	            return "S";
 	        if(c==boolean.class)
 	            return "Z";
 	        if(c==void.class)
 	            return "V";
 	    }
 	    if(c.isArray()) 
 	    		return c.getName().replace('.', '/');
 	    return ('L'+c.getName()+';').replace('.', '/');
 	}
 	@Override
@ -672,6 +828,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	@Override
 	public void visit(UnaryExpr unaryExpr) {
 		unaryExpr.expr.accept(this);
 		Operation op = unaryExpr.operation;
@ -799,7 +956,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		statement = new LoopStmt(whileStmt.expr, whileStmt.loopBlock);
 		isBinaryExp = statement.isExprBinary();
 		whileStmt.expr.accept(this);
-		isBinaryExp = false;
+//		isBinaryExp = false;
 		statement = null;
 	}
@ -819,7 +976,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	}
 	// Unboxing: RefType -> prim
-	private void doUnboxing(String type) {
+	public void doUnboxing(String type) {
 		switch (type) {
 		case "java/lang/String":
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(StringBuilder.class), "append",
@ -1040,13 +1197,9 @@ public class BytecodeGenMethod implements StatementVisitor {
 		String var = assignLeftSide.localVar.name;
 		if (!paramsAndLocals.containsKey(var)) {
 			paramsAndLocals.put(var, index + 1);
-		} else {
+		} 
-			paramsAndLocals.put(var, index);
+		
-		}
+		mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.get(var));
 		mv.visitVarInsn(Opcodes.ASTORE, paramsAndLocals.size());
 		// Debug:::
 	}
 }
--- a/src/de/dhbwstuttgart/bytecode/LoopStmt.java
+++ b/src/de/dhbwstuttgart/bytecode/LoopStmt.java
@ -18,6 +18,7 @@ public class LoopStmt extends AStatement {
 	@Override
 	public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
 		bytecodeGenMethod.isBinary(false);
 		this.loopBlock.accept(bytecodeGenMethod);
 		mv.visitJumpInsn(Opcodes.GOTO, endLabel);
 		mv.visitLabel(branchLabel);
--- a/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
+++ b/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
@ -2,6 +2,8 @@ package de.dhbwstuttgart.bytecode.descriptor;
 import java.util.Iterator;
 import org.objectweb.asm.Type;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.utilities.Lambda;
 import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
@ -49,7 +51,8 @@ public class DescriptorToString implements DescriptorVisitor{
 //					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 					if(resType.subSequence(0, 4).equals("TPH ")) {
-						desc += "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
+						// Bound ist immer Object
 						desc += "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
 						desc += "L"+resType+ ";";
 					}
@ -76,7 +79,8 @@ public class DescriptorToString implements DescriptorVisitor{
 				}else {
 					String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 					if(resType.subSequence(0, 4).equals("TPH ")) {
-						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
+//						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
 						desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
 						desc += ")" + "L"+resType+ ";";
 					}
@ -119,9 +123,21 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc = desc + "L"+ d + ";";
 			}
 		}
 		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
 		}
 		desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
 		return desc;
 	}
@ -131,9 +147,22 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
 		while(itr.hasNext()) {
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
-			desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
+			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
 			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc += "L"+ d + ";";
 			}
 		}
 		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
 		}
 		desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 		return desc;
 	}
@ -141,26 +170,34 @@ public class DescriptorToString implements DescriptorVisitor{
 	public String visit(MethodFromMethodCall methodFromMethodCall) {
 		String desc = "(";
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
-			String d = e.getType().acceptTV(new TypeToDescriptor());
+			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
+			
-				desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
 				desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
 			}else {
-				desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
 					desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
 				}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
 					desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
 				}else {
 					desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 				}
 			}
 		}
-		
+		String retType = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
-		if(resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.toString().equals("void")) {
+		System.out.println("DescriptorToString retType = " + retType);
 		if(retType.equals("void")) {
 			desc += ")V";
 		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
-			String ret = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(ret)) {
+				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(retType)+ ";";
-				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(ret)+ ";";
+			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(retType)){
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(ret)){
+				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(retType)+ ";";
 				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(ret)+ ";";
 			}else {
-				desc += ")" + "L"+resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				desc += ")" + "L"+retType+ ";";
 			}
 		}
 //		desc = addReturnType(desc, methodFromMethodCall.getReturnType(), resultSet);
--- a/src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java
+++ b/src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java
@ -19,7 +19,9 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
 		return superWildcardType.getInnerType().toString().replace(".", "/");
 		//throw new NotImplementedException();
 	}
 	@Override
@ -29,6 +31,7 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
 		System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
 		return extendsWildcardType.getInnerType().toString().replace(".", "/");
 		//throw new NotImplementedException();
 	}
--- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
@ -1,5 +1,6 @@
 package de.dhbwstuttgart.bytecode.signature;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@ -8,13 +9,19 @@ import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 import de.dhbwstuttgart.typeinference.result.ResolvedType;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 public class Signature {
@ -26,28 +33,36 @@ public class Signature {
 	private Method method;
 	private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
 	private ResultSet resultSet;
 	private ArrayList<GenericInsertPair> commonPairs;
 	private ArrayList<GenericInsertPair> methodPairs;
-	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds) {
+	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,ArrayList<GenericInsertPair> commonPairs) {
 		this.classOrInterface = classOrInterface;
 		this.genericsAndBounds = genericsAndBounds;
 		this.commonPairs = commonPairs;
 		sw = new SignatureWriter();
 		createSignatureForClassOrInterface();
 	}
-	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes) {
+	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, 
 			HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes,ResultSet resultSet,ArrayList<GenericInsertPair> methodPairs) {
 		this.constructor = constructor;
 		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
 		this.resultSet = resultSet;
 		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.constructor,true);
 	}
-	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,
+	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,HashMap<String, String> genericsAndBounds,
-			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet) {
+			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet, ArrayList<GenericInsertPair> methodPairs) {
 		this.method = method;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
 		this.resultSet = resultSet;
 		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.method,false);
 	}
@ -92,27 +107,97 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBoundsMethod);
 		}
 		// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
 		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
-		String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+		if(!isConstructor) {
-		if(ret.substring(0,4).equals("TPH ")) {
+			String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
-			String g = ret.substring(4)+"$";
+			System.out.println("RET:::: " + ret);
-			sw.visitFormalTypeParameter(g);
+//			if(ret.substring(0,4).equals("TPH ")) {
-			sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+//				String g = ret.substring(4,ret.length())+"$";
-			genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
+				if(genericsAndBounds.containsKey(ret)) {
-			sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(ret, genericsAndBounds.get(ret));
 				}else {
 					sw.visitFormalTypeParameter(ret);
 					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
 					genericsAndBoundsMethod.put(ret, Type.getInternalName(Object.class));
 					sw.visitClassBound().visitEnd();
 				}
 //			}
 			if(ret.contains("<")) {
 				RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
 				if(hasTPHs(ref)) {
 					createSignatureForParameterizedType(ref);
 				}
 			}
 		}
 		// Parameters
 		for(String paramName : methodParamsAndTypes.keySet()) {
 			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
 			String pT = t.acceptTV(new TypeToSignature()); 
 			// S.o
-			if(pT.substring(0,4).equals("TPH ") && !genericsAndBoundsMethod.containsKey(pT)) {
+//			if(pT.substring(0,4).equals("TPH ")) {
-				String gP = pT.substring(4)+"$";
+			if(t instanceof TypePlaceholder) {
-				sw.visitFormalTypeParameter(gP);
+//				String gP = pT.substring(4,pT.length())+"$";
-				sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+				String gP = t.acceptTV(new TypeToSignature());
-				genericsAndBoundsMethod.put(gP, Type.getInternalName(Object.class));
+				if(!genericsAndBounds.containsKey(gP) && !genericsAndBoundsMethod.containsKey(gP)) {
-				sw.visitClassBound().visitEnd();
+					sw.visitFormalTypeParameter(gP);
 					String bound = Type.getInternalName(Object.class);
 					boolean isTypeVar = false;
 					for(GenericInsertPair pair : methodPairs) {
 						if(pT.substring(0,pT.length()).equals(pair.TA1.getName())) {
 							bound = pair.TA2.getName()+"$";
 							isTypeVar = true;
 							break;
 						}
 					}
 					if(isTypeVar) {
 						sw.visitClassBound().visitTypeVariable(bound);
 					}else {
 						sw.visitClassBound().visitClassType(bound);
 						sw.visitClassBound().visitEnd();
 					}
 					genericsAndBoundsMethod.put(gP, bound);
 				}
 			}
 			if(pT.contains("<")) {
 				RefType ref = (RefType) methodParamsAndTypes.get(paramName);
 				if(hasTPHs(ref))
 					createSignatureForParameterizedType(ref);
 			}
 			for(GenericInsertPair p:methodPairs) {
 				String name = p.TA1.getName()+"$";
 				if(!genericsAndBoundsMethod.containsKey(name)) {
 					sw.visitFormalTypeParameter(name);
 					sw.visitClassBound().visitTypeVariable(p.TA2.getName()+"$");
 					genericsAndBoundsMethod.put(name, p.TA2.getName()+"$");
 				}
 			}
 			ArrayList<TypePlaceholder> types = new ArrayList<>();
 			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
 			for(GenericInsertPair p : methodPairs) {
 				types.add(p.TA1);
 				superTypes.add(p.TA2);
 			}
 			for(GenericInsertPair p : methodPairs) {
 				String name = p.TA2.getName()+"$";
 				if(!types.contains(p.TA2) && !genericsAndBoundsMethod.containsKey(name)) {
 					String bound = Type.getInternalName(Object.class);
 					sw.visitFormalTypeParameter(name);
 					sw.visitClassBound().visitClassType(bound);
 					genericsAndBoundsMethod.put(name, bound);
 					sw.visitClassBound().visitEnd();
 				}
 			}
 		}
@ -125,21 +210,152 @@ public class Signature {
 		if(isConstructor) {
 			sw.visitReturnType().visitBaseType('V');
 		}else {
 //			String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()); 
 //			if(ret.substring(0,4).equals("TPH ")) {
 //				String g = ret.substring(4);
 //				if(!genericsAndBoundsMethod.containsKey(g)) {
 //					genericsAndBoundsMethod.put(g, Type.getInternalName(Object.class));
 //				} else {
 //					genericsAndBoundsMethod.put(g+"_", Type.getInternalName(Object.class));
 //				}
 //			}
 			RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
 			// return type deswegen ist false
 			doVisitParamsOrReturn(returnType, false);
 		}
 //		sw.visitEnd();
 	}
 	private void createSignatureForParameterizedType(RefType ref) {
 		ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
 		allPairs.addAll(methodPairs);
 		ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
 		HashMap<String, String> names = new HashMap<>();
 		for(GenericInsertPair pair : simplifiedPairs) {
 			if(ref.getParaList().contains(pair.TA1)) {
 				String sub = pair.TA1.getName()+"$";
 				String superT = pair.TA2.getName()+"$";
 				names.put(sub, superT);
 			}
 		}
 		for(String sub : names.keySet()) {
 			if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
 				sw.visitFormalTypeParameter(sub);
 				String bound = names.get(sub);
 				sw.visitClassBound().visitTypeVariable(bound);
 				genericsAndBoundsMethod.put(sub, bound);
 			}
 		}
 		for(String superT : names.values()) {
 			if(!names.containsKey(superT)) {
 				if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
 					sw.visitFormalTypeParameter(superT);
 					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
 					sw.visitClassBound().visitEnd();
 					genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
 				}
 			}
 		}
 		for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
 			if(p instanceof TypePlaceholder) {
 				String name = ((TypePlaceholder) p).getName() + "$";
 				if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
 					sw.visitFormalTypeParameter(name);
 					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
 					sw.visitClassBound().visitEnd();
 					genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
 				}
 			}
 		}
 	}
 	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
 		final ArrayList<GenericInsertPair> res = new ArrayList<>();
 		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
 			RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
 			if(resolved instanceof TypePlaceholder) {
 				resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
 					if(!contains(res,ag)) {
 						res.add(ag);
 					}
 				});
 			}
 		}
 		return res;
 	}
 	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
 		for(int i=0; i<pairs.size();++i) {
 			GenericInsertPair p = pairs.get(i);
 			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
 				return true;
 		}
 		return false;
 	}
 	private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
 		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
 		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
 		for(GenericInsertPair p : allPairs) {
 			subAndSuperTph.put(p.TA1, p.TA2);
 		}
 		subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
 		int numOfVisitedPairs = 0;
 		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
 			if(numOfVisitedPairs>=subAndSuperTph.size())
 				break;
 			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
 			tphsInRel.put(tphsInRel.size(), subTph);
 			TypePlaceholder superTph = subAndSuperTph.get(subTph);
 			tphsInRel.put(tphsInRel.size(), superTph);
 			numOfVisitedPairs++;
 			while(subAndSuperTph.containsKey(superTph)) {
 				superTph = subAndSuperTph.get(superTph);
 				tphsInRel.put(tphsInRel.size(), superTph);
 				numOfVisitedPairs++;
 			}
 			// Subtype
 			TypePlaceholder subTphRes = tphsInRel.get(0);
 			// Die größte Supertype
 			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
 			while(subAndSuperTph.containsValue(subTphRes)) {
 				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
 					if(subAndSuperTph.get(tph).equals(subTphRes)) {
 						subTphRes = tph;
 						break;
 					}
 				}
 				tphsInRel.put(0, subTphRes);
 				numOfVisitedPairs++;
 			}
 			subTphRes = tphsInRel.get(0);
 			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
 			simplifiedPairs.add(sPair);
 		}
 		return simplifiedPairs;
 	}
 	private boolean hasTPHs(RefType ref) {
 		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
 			System.out.println(p.acceptTV(new TypeToString()));
 			if(p.acceptTV(new TypeToString()).contains("WC")){
 				continue;
 			}
 			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
 				return true;
 		}
 		return false;
 	}
 	/**
 	 * Visits parameter type or return type with {@link SignatureVisitor} to create
 	 * the method signature
@ -157,7 +373,8 @@ public class Signature {
 		}
 		switch (type) {
 		case "RT":
-			sv.visitClassType(t.acceptTV(new TypeToSignature()));
+			String sig = t.acceptTV(new TypeToSignature());
 			sv.visitClassType(sig.substring(1, sig.length()));
 			break;
 		case "GRT":
 			GenericRefType g = (GenericRefType) t;
@ -168,13 +385,22 @@ public class Signature {
 			// der Fall wenn die Type eine Interface ist, muss betrachtet werden
 			// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
 			// Interface oder eine Klasse ist.
-			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+			
 			// das braucht man nicht es reicht: sv.visitTypeVariable(r.acceptTV(new TypeToSignature())
 			// 
 //			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
 			String sig2 = r.acceptTV(new TypeToSignature());
 			if(!(r instanceof TypePlaceholder)) {
 //				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
-				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+//				sv.visitClassType(r.acceptTV(new TypeToSignature()));
 				sv.visitClassType(sig2.substring(1, sig2.length()));
 			} else {
 				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
-				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+//				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
 				sv.visitTypeVariable(sig2.substring(1, sig2.length()));
 			}
 			break;
 		default:
 			if(!isParameterType)
@ -194,7 +420,34 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBounds);
 		}
-		
+		if(!commonPairs.isEmpty()) {
 			ArrayList<TypePlaceholder> types = new ArrayList<>();
 			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
 			for(GenericInsertPair p : commonPairs) {
 				types.add(p.TA1);
 				superTypes.add(p.TA2);
 			}
 			for(GenericInsertPair p : commonPairs) {
 				String t = p.TA1.getName()+"$";
 				String bound = p.TA2.getName()+"$";
 				sw.visitFormalTypeParameter(t);
 				sw.visitClassBound().visitTypeVariable(bound);
 				genericsAndBounds.put(t, bound);
 			}
 			for(GenericInsertPair p : commonPairs) {
 				if(!types.contains(p.TA2)) {
 					String t = p.TA2.getName()+"$";
 					String bound = Type.getInternalName(Object.class);
 					sw.visitFormalTypeParameter(t);
 					sw.visitClassBound().visitClassType(bound);
 					genericsAndBounds.put(t, bound);
 					sw.visitClassBound().visitEnd();
 				}
 			}
 		}
 		sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
 		sw.visitEnd();
 	}
--- a/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
@ -22,29 +22,41 @@ public class TypeToSignature implements TypeVisitor<String> {
            Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
            while(it.hasNext()){
                RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-                params += "L"+param.toString().replace(".", "/");
+//                if(param instanceof TypePlaceholder) {
 //                	params += "T" + ((TypePlaceholder) param).getName() + "$";
 //                } else if(param instanceof ExtendsWildcardType) {
 //                	params += "+" + ((ExtendsWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
 //                } else if(param instanceof SuperWildcardType) {
 //                	params += "-" + ((SuperWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
 //                } else {
 //                		params += "L"+param.toString().replace(".", "/");
 //                }
                params += param.acceptTV(new TypeToSignature());
                if(it.hasNext())params += ";";
            }
-            params += ";>";
+            params += ">";
        }
 //        		String t = refType.getName().toString().replace(".", "/");
 //        		return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
-        return refType.getName().toString().replace(".", "/") + params+";";
+        return "L"+refType.getName().toString().replace(".", "/") + params+";";
 	}
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
 		return "-" + superWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 	@Override
 	public String visit(TypePlaceholder typePlaceholder) {
-		return typePlaceholder.toString().replace(".", "/");
+//		return typePlaceholder.toString().replace(".", "/");
 		return "T" + typePlaceholder.getName() + "$";
 	}
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
 		return "+" + extendsWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 	@Override
--- a/src/de/dhbwstuttgart/bytecode/signature/TypeToString.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/TypeToString.java
@ -17,7 +17,7 @@ public class TypeToString implements TypeVisitor<String>{
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		return "SWC";
 	}
 	@Override
@ -27,7 +27,7 @@ public class TypeToString implements TypeVisitor<String>{
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+		return "EWC";
 	}
 	@Override
--- a/src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java
+++ b/src/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java
@ -0,0 +1,29 @@
 package de.dhbwstuttgart.bytecode.utilities;
 import java.util.ArrayList;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 public class MethodAndTPH {
 	private String name;
 	private final ArrayList<TypePlaceholder> tphs = new ArrayList<>();
 	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
 	public MethodAndTPH(String name) {
 		this.name = name;
 	}
 	public ArrayList<TypePlaceholder> getTphs() {
 		return tphs;
 	}
 	public ArrayList<GenericInsertPair> getPairs(){
 		return pairs;
 	}
 	public String getName() {
 		return name;
 	}
 }
--- a/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java
+++ b/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java
@ -9,13 +9,16 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 public class MethodFromMethodCall {
 	private ArgumentList argList;
 	private RefTypeOrTPHOrWildcardOrGeneric returnType;
 	private String receiverName;
 	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String,String> genericsAndBounds;
-	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType,
+	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType, 
-			HashMap<String, String> genericsAndBoundsMethod,HashMap<String,String> genericsAndBounds) {
+			String receiverName, HashMap<String, String> genericsAndBoundsMethod,
 			HashMap<String,String> genericsAndBounds) {
 		this.argList = argList;
 		this.returnType = returnType;
 		this.receiverName = receiverName;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
 	}
@ -28,6 +31,10 @@ public class MethodFromMethodCall {
 		return returnType;
 	}
 	public String getReceiverName() {
 		return receiverName;
 	}
 	public HashMap<String, String> getGenericsAndBoundsMethod(){
 		return genericsAndBoundsMethod;
 	}
--- a/src/de/dhbwstuttgart/core/JavaTXCompiler.java
+++ b/src/de/dhbwstuttgart/core/JavaTXCompiler.java
@ -110,13 +110,6 @@ public class JavaTXCompiler {
        TypeUnify unify = new TypeUnify();
        Set<Set<UnifyPair>> results = new HashSet<>();
        try {
 			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/test/logFiles/"+"log"));
 			logFile.write("FC:\\" + finiteClosure.toString()+"\n");
 			for(SourceFile sf : this.sourceFiles.values()) {
 				logFile.write(ASTTypePrinter.print(sf));
 			}
 			logFile.flush();
 			Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct(); 
 			for (List<Constraint<UnifyPair>> xCons : cardProd ){
 				Set<UnifyPair> xConsSet = new HashSet<>();
@ -175,15 +168,11 @@ public class JavaTXCompiler {
 					return y; } )
 				.collect(Collectors.toCollection(HashSet::new));
 					varianceInheritance(xConsSet);
-    				Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+    				Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure);
    				//Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
    				System.out.println("RESULT: " + result);
    				logFile.write("RES: " + result.toString()+"\n");
    				logFile.flush();
    				results.addAll(result);
            	}
-        	}
+ 
    		catch (IOException e) { }
 		return results.stream().map((unifyPairs ->
               new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
@ -240,25 +229,26 @@ public class JavaTXCompiler {
        SourceFile ret = generator.convert(tree, environment.packageCrawler);
        return ret;
    }
-    
+    // um pfad erweitern
-    public void generateBytecode() throws ClassNotFoundException, IOException {
+    public void generateBytecode(String path) throws ClassNotFoundException, IOException {
    		for(File f : sourceFiles.keySet()) {
    			HashMap<String,byte[]> classFiles = new HashMap<>();
    			SourceFile sf = sourceFiles.get(f);
    			List<ResultSet> typeinferenceResult = this.typeInference();
-    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult);
+    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,sf,path);
 //    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
        		bytecodeGen.visit(sf);
-        		this.writeClassFile(bytecodeGen.getClassFiles());
+        		this.writeClassFile(bytecodeGen.getClassFiles(), path);
    		}
    }
-	private void writeClassFile(HashMap<String, byte[]> classFiles) throws IOException {
+	private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
 		FileOutputStream output;
 		for(String name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
 			System.out.println("generating "+name+ ".class file ...");
-			output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
+			//output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
 			output = new FileOutputStream(new File(path +name+".class"));
 			output.write(bytecode);
 			output.close();
 			System.out.println(name+".class file generated");
--- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
+++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
@ -208,7 +208,7 @@ public class UnifyTypeFactory {
    }
    public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
        return ret;
    }
--- a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java
+++ b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java
@ -24,7 +24,7 @@ public class FunN extends RefType {
 	 * @return
 	 */
 	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
-		super(new JavaClassName("Fun"+params.size()), params, new NullToken());
+		super(new JavaClassName("Fun"+(params.size())), params, new NullToken());
 	}
 	/**
--- a/src/de/dhbwstuttgart/typedeployment/TypeInsert.java
+++ b/src/de/dhbwstuttgart/typedeployment/TypeInsert.java
@ -33,4 +33,22 @@ public class TypeInsert {
    public String getInsertString(){
        return point.getInsertString();
    }
    /* PL 2018-06-18
     * Zwei TypeInsert's sind gleich, wenn ihre point's und ihre inserts' gleich sind 
     * eingefuegt damit man TypeReplaceMarker vergleichen kann
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object obj) {
    	if(!(obj instanceof TypeInsert)) {
 			return false;
    	}
    	else {
    		return ((TypeInsert)obj).point.equals(this.point);
    	}			
    }
    public String toString() {
    	return point.toString();
    }
 }
--- a/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java
+++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java
@ -2,6 +2,8 @@ package de.dhbwstuttgart.typedeployment;
 import org.antlr.v4.runtime.Token;
 import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
 import java.util.List;
 import java.util.stream.Collectors;
@ -25,4 +27,23 @@ public class TypeInsertPoint {
    public String getInsertString() {
        return insertString;
    }
    /* PL 2018-06-19
     * Zwei TypeInsertPoint's sind gleich, wenn ihre point's gleich sind 
     * eingefuegt damit man TypeReplaceMarker vergleichen kann
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object obj) {
    	if(!(obj instanceof TypeInsertPoint)) {
 			return false;
    	}
    	else {
    		return ((TypeInsertPoint)obj).point.equals(this.point) &&
    				((TypeInsertPoint)obj).insertString.equals(this.insertString);
    	}			
    }
    public String toString() {
    	return point.toString() + " " + insertString.toString();
    }
 }
--- a/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
+++ b/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
@ -8,32 +8,36 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 import java.util.ArrayList;
 import java.util.List;
 public class FunNClass extends ClassOrInterface {
-    public FunNClass(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    public FunNClass(List<GenericRefType> funNParams) {
-        super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(),
+        super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(),
                createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
                ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
        }
-    private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static GenericDeclarationList createGenerics(List<GenericRefType> funNParams) {
    	//PL 2018-06-22: so geaendert, dass generierte Generics den Namen der funParams entsprechen.
        List<GenericTypeVar> generics = new ArrayList<>();
-        for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
+        for(GenericRefType param : funNParams){
-            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
+            generics.add(new GenericTypeVar(param.getParsedName(),//NameGenerator.makeNewName(),
                    new ArrayList<>(), new NullToken(), new NullToken()));
        }
        return new GenericDeclarationList(generics, new NullToken());
    }
-    private static List<Method> createMethods(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static List<Method> createMethods(List<GenericRefType> funNParams) {
        return null;
    }
 }
--- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
+++ b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
@ -16,10 +16,10 @@ import java.util.List;
 public class MethodAssumption extends Assumption{
    private ClassOrInterface receiver;
    private RefTypeOrTPHOrWildcardOrGeneric retType;
-    List<RefTypeOrTPHOrWildcardOrGeneric> params;
+    List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
    public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
        super(scope);
        this.receiver = receiver;
        this.retType = retType;
@ -38,7 +38,9 @@ public class MethodAssumption extends Assumption{
    }
    public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
-        if(retType instanceof GenericRefType)return resolver.resolve(retType);
+        if(retType instanceof GenericRefType) {
        	return resolver.resolve(retType);
        }
        return retType;
    }
--- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
@ -201,7 +202,7 @@ public class TYPEStmt implements StatementVisitor{
                unaryExpr.operation == UnaryExpr.Operation.PREINCREMENT){
            //@see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.14.2
            //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERDOT));
+            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERNEQDOT));
            //The type of the postfix increment expression is the type of the variable
            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), unaryExpr.getType(), PairOperator.EQUALSDOT));
        }else{
@ -327,7 +328,16 @@ public class TYPEStmt implements StatementVisitor{
    @Override
    public void visit(Literal literal) {
-        //Nothing to do here. Literale erzeugen keine Constraints
+        //Nothing to do here. Literale erzeugen keine Constraints 
    	//PL 2018-06-23 Sie haben einen Typ. Der muesste hier eingefuegt werden
    	//wie hier fuer double gezeigt. Im Momment auskommentiert, weil zu wenige Literaltypen
    	//funktionieren
    	//if (literal.value instanceof Double) {
    	//	constraintsSet.addUndConstraint(new Pair(literal.getType(), doublee, PairOperator.EQUALSDOT));
    	//}
    	//else {
    	//	throw new NotImplementedException();
    	//}
    }
    @Override
@ -451,11 +461,14 @@ public class TYPEStmt implements StatementVisitor{
        List<MethodAssumption> ret = new ArrayList<>();
        //TODO: apply Methoden wieder anfügen. Diese könnten möglicherweise auch in den Assumptions auftauchen (überdenken)
        if(name.equals("apply")){
-            List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
+            List<GenericRefType> funNParams = new ArrayList<>();
            for(int i = 0; i< numArgs + 1 ; i++){
-                funNParams.add(TypePlaceholder.fresh(new NullToken()));
+                //funNParams.add(TypePlaceholder.fresh(new NullToken()));
            	funNParams.add(new GenericRefType(NameGenerator.makeNewName(),
                        new NullToken()));
            }
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size()),
+            funNParams.get(funNParams.size()-1);
            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size()-1), funNParams.subList(0, funNParams.size()-1),
                    new TypeScope() {
                        @Override
                        public Iterable<? extends GenericTypeVar> getGenerics() {
@ -498,7 +511,7 @@ public class TYPEStmt implements StatementVisitor{
         */
        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
        for(FormalParameter fp : parameterList.getFormalparalist()){
-            params.add(info.checkGTV(fp.getType()));
+            params.add(fp.getType()); //info.checkGTV(fp.getType())); //PL 2018-06-22 GTV sollen in Argumenten erhalten bleiben
        }
        return params;
    }
--- a/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
@ -36,15 +36,10 @@ import java.io.IOException;
 */
 public class RuleSet implements IRuleSet{
 	FileWriter logFile;
 	RuleSet() {
 		super();
 	}
 	RuleSet(FileWriter logFile) {
 		this.logFile = logFile;
 	}
 	@Override
 	public Optional<UnifyPair> reduceUp(UnifyPair pair) {
@ -938,7 +933,9 @@ public class RuleSet implements IRuleSet{
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
-			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+			Set<UnifyType> fBounded = pair.getfBounded();
 			fBounded.add(lhsType);
 			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
 		}
 		return Optional.of(result);
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java
@ -8,16 +8,16 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 public class TypeUnify {
-	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true, logFile, log);
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}
-	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
+	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false, logFile, log);
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
 		return res;
 	}
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@ -13,6 +13,7 @@ import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.RecursiveTask;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@ -49,8 +50,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private boolean printtag = false;
 	Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
-	public static final String rootDirectory = System.getProperty("user.dir")+"/test/logFiles/";
+	//public static final String rootDirectory = System.getProperty("user.dir")+"/test/logFiles/";
 	FileWriter logFile;
 	/**
 	 * The implementation of setOps that will be used during the unification
@ -87,14 +87,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		rules = new RuleSet();
 	}
-	public TypeUnifyTask(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel, FileWriter logFile, Boolean log) {
+	public TypeUnifyTask(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel) {
 		this.eq = eq;
 		this.fc = fc;
 		this.oup = new OrderingUnifyPair(fc);
 		this.parallel = parallel;
-		this.logFile = logFile;
+		rules = new RuleSet();
 		this.log = log;
 		rules = new RuleSet(logFile);
 	}
@ -144,17 +142,16 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	 * @return The set of all principal type unifiers
 	 */
 	protected Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel)  {
-		Set<UnifyPair> aas = eq.stream().filter(x -> x.getLhsType().getName().equals("AA") //&& x.getPairOp().equals(PairOperator.SMALLERDOT)
+		//Set<UnifyPair> aas = eq.stream().filter(x -> x.getLhsType().getName().equals("AA") //&& x.getPairOp().equals(PairOperator.SMALLERDOT)
-				).collect(Collectors.toCollection(HashSet::new));
+		//		).collect(Collectors.toCollection(HashSet::new));
-		writeLog(nOfUnify.toString() + " AA: " + aas.toString());
+		//writeLog(nOfUnify.toString() + " AA: " + aas.toString());
-		if (aas.isEmpty()) {
+		//if (aas.isEmpty()) {
-			System.out.println("");
+		//	System.out.println("");
-		}
+		//}
 		/*
 		 * Step 1: Repeated application of reduce, adapt, erase, swap 
 		 */
 		nOfUnify++;
        writeLog(nOfUnify.toString() + " Unifikation: " + eq.toString());
 		//eq = eq.stream().map(x -> {x.setVariance((byte)-1); return x;}).collect(Collectors.toCollection(HashSet::new));
 		/*
@ -230,10 +227,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		// those pairs are contradictory and the unification is impossible.
 		if(!undefinedPairs.isEmpty()) {
 			noUndefPair++;
 			for (UnifyPair up : undefinedPairs) {
 				writeLog(noUndefPair.toString() + " UndefinedPairs; " + up);
 				writeLog("BasePair; " + up.getBasePair());
 			}
 			Set<Set<UnifyPair>> error = new HashSet<>();
 			undefinedPairs = undefinedPairs.stream().map(x -> { x.setUndefinedPair(); return x;}).collect(Collectors.toCollection(HashSet::new));
 			error.add(undefinedPairs);
@ -322,13 +315,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					eqPrimePrimeSet.add(eqPrime);
 				else if(eqPrimePrime.isPresent()) {
 					//System.out.println("nextStep: " + eqPrimePrime.get());
-					TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc, true, logFile, log);
+					TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc, true);
 					forks.add(fork);
 					fork.fork();
 				}
 				else {
 					//System.out.println("nextStep: " + eqPrime);
-					TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc, true, logFile, log);
+					TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc, true);
 					forks.add(fork);
 					fork.fork();
 				}
@ -339,13 +332,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 																			  //PL 2017-09-29 dies ersetzt //(!eqPrimePrime.isPresent()) 
 																			  //PL 2018-05-18 beide Bedingungen muessen gelten, da eqPrime Veränderungen in allem ausser subst
 																			  //eqPrimePrime Veraenderungen in subst repraesentieren.
-					try {
+					
 						if (isSolvedForm(eqPrime)) {
 							logFile.write(eqPrime.toString()+"\n");
 							logFile.flush();
 						}
 					}
 					catch (IOException e) { }
 					eqPrimePrimeSet.add(eqPrime);
 				}
 				else if(eqPrimePrime.isPresent()) {
@ -376,8 +363,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		  * Step 7: Filter empty sets;
 		  */
 		eqPrimePrimeSet = eqPrimePrimeSet.stream().filter(x -> isSolvedForm(x) || this.isUndefinedPairSet(x)).collect(Collectors.toCollection(HashSet::new));
 		if (!eqPrimePrimeSet.isEmpty() && !isUndefinedPairSetSet(eqPrimePrimeSet))
 			writeLog("Result1 " + eqPrimePrimeSet.toString());
 		return eqPrimePrimeSet;
 	}
@ -397,7 +382,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			return result;
 		}
 		Set<Set<UnifyPair>> nextSet = remainingSets.remove(0);
 		writeLog("nextSet: " + nextSet.toString());
 		List<Set<UnifyPair>> nextSetasList =new ArrayList<>(nextSet);
 		try {
 		//List<Set<UnifyPair>> 
@ -488,6 +472,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			Set<Set<UnifyPair>> elems = new HashSet<Set<UnifyPair>>(fstElems);
 			elems.add(a);
 			//if (remainingSets.isEmpty()) {//muss immer gegeben sein, weil nur 1 Element der topLevelSets mehr als ein Elemet enthaelt
 				//writeLog("Vor unify2 Aufruf: " + eq.toString());
 				Set<Set<UnifyPair>> res = unify2(elems, eq, fc, parallel);
 				if (!isUndefinedPairSetSet(res) && isUndefinedPairSetSet(result)) {
 					//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
@ -512,7 +497,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//else {//duerfte gar nicht mehr vorkommen PL 2018-04-03
 				//result.addAll(computeCartesianRecursive(elems, remainingSets, eq, fc, parallel)); 
 			//}
-			
+				
 			/* auskommentiert um alle Max und min Betrachtung auszuschalten ANFANG */
 			if (!result.isEmpty() && !isUndefinedPairSetSet(res)) {
 				if (nextSetasList.iterator().hasNext() && nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("D")).findFirst().isPresent() && nextSetasList.size()>1) 
 					System.out.print("");
@ -542,6 +528,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 				}
 			}
 			 /* auskommentiert um alle Max und min Betrachtung auszuschalten ENDE */ 
 			if (isUndefinedPairSetSet(res)) {
 				Set<UnifyPair> abhSubst = res.stream()
 							   .map(b -> 
@ -563,16 +551,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					//}
 					return (!x.containsAll(durchschnitt));
 				}).collect(Collectors.toCollection(ArrayList::new));
 				writeLog("abhSubst: " + abhSubst.toString());
 				writeLog("a: " + a.toString());
 				writeLog("Durchschnitt: " + durchschnitt.toString());
 				writeLog("nextSet: " + nextSet.toString());
 				writeLog("nextSetasList: " + nextSetasList.toString());
 				writeLog("Number erased Elements (undef): " + (len - nextSetasList.size()));
 				noAllErasedElements = noAllErasedElements + (len - nextSetasList.size());
 				writeLog("Number erased Elements (undef): " + noAllErasedElements.toString());
 				noBacktracking++;
 				writeLog("Number of Backtracking: " + noBacktracking);
 				System.out.println("");
 			}
 			//if (nextSetasList.size() == 0 && isUndefinedPairSetSet(result) && nextSet.size() > 1) { 
@ -1094,7 +1074,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		UnifyType supAPrime = new SuperType(aPrime);
 		UnifyType thetaPrime = subThetaPrime.getSuperedType();
 		Set<UnifyPair> resultPrime = new HashSet<>();
-		resultPrime.add(new UnifyPair(thetaPrime, a, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime.add(new UnifyPair(thetaPrime, a, PairOperator.SMALLERDOT, pair.getSubstitution(), pair, pair.getfBounded()));
 		result.add(resultPrime);
 		//writeLog(resultPrime.toString());
@ -1124,14 +1104,34 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				break;
 			}
-		for(UnifyType thetaS : fc.greater(theta, new HashSet<>())) {
+		for(UnifyType thetaS : fc.greater(theta, pair.getfBounded())) {
 			Set<UnifyPair> resultPrime = new HashSet<>();
 			Match match = new Match();
 			UnifyType[] freshTphs = new UnifyType[thetaS.getTypeParams().size()];
 			for(int i = 0; !allGen && i < freshTphs.length; i++) {
 				freshTphs[i] = PlaceholderType.freshPlaceholder();
 				((PlaceholderType)freshTphs[i]).setVariance(((PlaceholderType)a).getVariance());
-				resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair));
+				Set<UnifyType> fBounded = pair.getfBounded();
 				int i_ef = i;
 				BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
 				{
 					ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
 				    termList.add(new UnifyPair(y,thetaS.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
 				    return ((match.match(termList).isPresent()) || x);
 				};
 				//if (parai.getName().equals("java.lang.Integer")) {
 				//	System.out.println("");
 				//}
 				BinaryOperator<Boolean> bo = (x,y) -> (x || y);
 				if (fBounded.stream().reduce(false,f,bo)) {
 					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 				}
 				else {
 					fBounded.add(thetaS.getTypeParams().get(i));
 					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair, fBounded));
 				}	
 			}
 			if(allGen)
@ -1165,9 +1165,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		((PlaceholderType)freshTph).setVariance(a.getVariance());
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
-		resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair, pair.getfBounded()));
 		result.add(resultPrime);
-		//writeLog(resultPrime.toString());
+		//writeLog("resultPrime: " + resultPrime.toString());
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
@ -1212,7 +1212,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			permuteParams(candidates, idx+1, result, current);
 		}
 	}
-	
+/*	
 	void writeLog(String str) {
 		if (log) {
 			try {
@ -1223,4 +1223,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			catch (IOException e) { }
 			}
 	}
 	*/
 }
--- a/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
@ -102,7 +102,7 @@ public class Unifier implements Function<UnifyType, UnifyType>, Iterable<Entry<P
 			}
 			return new UnifyPair(newLhs, newRhs, p.getPairOp(), suniUnifyPair, p);
 		}
-		return new UnifyPair(newLhs, newRhs, p.getPairOp(), p.getSubstitution(), p.getBasePair());
+		return new UnifyPair(newLhs, newRhs, p.getPairOp(), p.getSubstitution(), p.getBasePair(), p.getfBounded());
 	}
 	/**
--- a/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
@ -50,6 +50,13 @@ public class UnifyPair {
     * PL 2018-03-15
     */
    private UnifyPair basePair;
    /**
     * For pairs a <. Theta generated in the rule reduceTphSup
     * to store the f-Bouned Elements to avoid endless recursion 
     * PL 2018-03-15
     */
    private Set<UnifyType> fBounded = new HashSet<>();
 	private final int hashCode;
@ -82,6 +89,12 @@ public class UnifyPair {
 		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
 	}	
 	public UnifyPair(UnifyType lhs, UnifyType rhs, PairOperator op, Set<UnifyPair> uni, UnifyPair base, Set<UnifyType> fBounded) {
 		this(lhs, rhs, op, uni, base);
 		this.fBounded = fBounded;
 	}
 	/**
 	 * Returns the type on the left hand side of the pair.
 	 */
@ -138,6 +151,10 @@ public class UnifyPair {
 		return lhs.wrongWildcard() || rhs.wrongWildcard();
 	}
 	public Set<UnifyType> getfBounded() {
 		return this.fBounded;
 	}
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof UnifyPair))
@ -177,7 +194,7 @@ public class UnifyPair {
 		if (rhs instanceof PlaceholderType) {
 			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString();
 		}
-		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ")";
+		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ", [" + getfBounded().toString()+ "])";
 	}
 	/*
--- a/target/JavaTXcompiler-0.1-jar-with-dependencies.jar
+++ b/target/JavaTXcompiler-0.1-jar-with-dependencies.jar
--- a/test/bytecode/BinaryTest.java
+++ b/test/bytecode/BinaryTest.java
@ -25,8 +25,8 @@ public class BinaryTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/BinaryInMeth.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("BinaryInMeth");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/FacTest.java
+++ b/test/bytecode/FacTest.java
@ -27,8 +27,8 @@ public class FacTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Fac.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Fac");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
@ -37,8 +37,8 @@ public class FacTest {
 	@Test
 	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 		Method getFac = classToTest.getDeclaredMethod("getFac", Integer.class);
-		Integer result = (Integer) getFac.invoke(instanceOfClass,3);
+		Double result = (Double) getFac.invoke(instanceOfClass,3);
-		assertEquals(result, 6);
+		assertEquals(result, 6.0);
 	}
 }
--- a/test/bytecode/GenTest.java
+++ b/test/bytecode/GenTest.java
@ -26,8 +26,8 @@ public class GenTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Gen.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Gen");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/GreaterEqualTest.java
+++ b/test/bytecode/GreaterEqualTest.java
@ -28,8 +28,8 @@ public class GreaterEqualTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/GreaterEqual.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("File://"+pathToClassFile)});
 		classToTest = loader.loadClass("GreaterEqual");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/GreaterThanTest.java
+++ b/test/bytecode/GreaterThanTest.java
@ -28,8 +28,8 @@ public class GreaterThanTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/GreaterThan.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("File://"+pathToClassFile)});
 		classToTest = loader.loadClass("GreaterThan");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/LambdaTest.java
+++ b/test/bytecode/LambdaTest.java
@ -16,7 +16,7 @@ public class LambdaTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Lambda.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
-		compiler.generateBytecode();
+		compiler.generateBytecode(System.getProperty("user.dir")+"/testBytecode/generatedBC/");
 	}
--- a/test/bytecode/LessEqualTest.java
+++ b/test/bytecode/LessEqualTest.java
@ -28,8 +28,8 @@ public class LessEqualTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/LessEqual.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("LessEqual");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/LessThanTest.java
+++ b/test/bytecode/LessThanTest.java
@ -28,8 +28,8 @@ public class LessThanTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/LessThan.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("LessThan");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/MatrixTest.java
+++ b/test/bytecode/MatrixTest.java
@ -3,8 +3,12 @@ package bytecode;
 import static org.junit.Assert.*;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Vector;
 import org.junit.BeforeClass;
 import org.junit.Test;
@ -20,21 +24,46 @@ public class MatrixTest {
 	private static String pathToClassFile;
 	private static Object instanceOfClass;
-	@BeforeClass
+//	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
+//	public static void setUpBeforeClass() throws Exception {
 //		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Matrix.jav";
 //		fileToTest = new File(path);
 //		compiler = new JavaTXCompiler(fileToTest);
 //		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 //		compiler.generateBytecode(pathToClassFile);
 //		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 //		classToTest = loader.loadClass("Matrix");
 //		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 //	}
 	@Test
 	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException {
 //		Vector<Vector<Integer>> m1 = new Vector<>();
 //		Vector<Integer> r1 = new Vector<>();
 //		r1.addElement(1);
 //		r1.addElement(0);
 //		m1.addElement(r1);
 //		Vector<Integer> r2 = new Vector<>();
 //		r2.addElement(0);
 //		r2.addElement(1);
 //		m1.add(r2);
 //		
 //		Vector<Vector<Integer>> m2 = new Vector<>();
 //		Vector<Integer> mr1 = new Vector<>();
 //		mr1.addElement(1);
 //		mr1.addElement(2);
 //		m2.add(mr1);
 //		Vector<Integer> mr2 = new Vector<>();
 //		mr2.addElement(3);
 //		mr2.addElement(4);
 //		m2.add(mr2);
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Matrix.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
-		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		compiler.generateBytecode(pathToClassFile);
-		classToTest = loader.loadClass("Matrix");
+		
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 	@Test
 	public void test() {
 		fail("Not yet implemented");
 	}
 }
--- a/test/bytecode/OLTest.java
+++ b/test/bytecode/OLTest.java
@ -25,8 +25,8 @@ public class OLTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/OL.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("OL");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/OpTest.java
+++ b/test/bytecode/OpTest.java
@ -28,8 +28,8 @@ public class OpTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Op.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Op");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/OverloadingTest.java
+++ b/test/bytecode/OverloadingTest.java
@ -30,8 +30,8 @@ public class OverloadingTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Overloading.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Overloading");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/PlusTest.java
+++ b/test/bytecode/PlusTest.java
@ -27,9 +27,8 @@ public class PlusTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Plus.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Plus");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/PostIncTest.java
+++ b/test/bytecode/PostIncTest.java
@ -27,8 +27,8 @@ public class PostIncTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/PostIncDec.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("PostIncDec");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/PreIncTest.java
+++ b/test/bytecode/PreIncTest.java
@ -27,8 +27,8 @@ public class PreIncTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/PreInc.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://" + pathToClassFile)});
 		classToTest = loader.loadClass("PreInc");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/RelOpsTest.java
+++ b/test/bytecode/RelOpsTest.java
@ -27,8 +27,8 @@ public class RelOpsTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/RelOps.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("RelOps");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/StaticTest.java
+++ b/test/bytecode/StaticTest.java
@ -26,8 +26,8 @@ public class StaticTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/StaticM.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://" + pathToClassFile)});
 		classToTest = loader.loadClass("StaticM");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/Tph2Test.java
+++ b/test/bytecode/Tph2Test.java
@ -0,0 +1,41 @@
 package bytecode;
 import static org.junit.Assert.*;
 import java.io.File;
 import java.net.URL;
 import java.net.URLClassLoader;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 public class Tph2Test {
 	private static String path;
 	private static File fileToTest;
 	private static JavaTXCompiler compiler;
 	private static ClassLoader loader;
 	private static Class<?> classToTest;
 	private static String pathToClassFile;
 	private static Object instanceOfClass;
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Tph2.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Tph2");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 	@Test
 	public void test() {
 		fail("Not yet implemented");
 	}
 }
--- a/test/bytecode/TphTest.java
+++ b/test/bytecode/TphTest.java
@ -0,0 +1,40 @@
 package bytecode;
 import static org.junit.Assert.*;
 import java.io.File;
 import java.net.URL;
 import java.net.URLClassLoader;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 public class TphTest {
 	private static String path;
 	private static File fileToTest;
 	private static JavaTXCompiler compiler;
 	private static ClassLoader loader;
 	private static Class<?> classToTest;
 	private static String pathToClassFile;
 	private static Object instanceOfClass;
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Tph.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("Tph");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 	@Test
 	public void test() {
 		fail("Not yet implemented");
 	}
 }
--- a/test/bytecode/WhileTest.java
+++ b/test/bytecode/WhileTest.java
@ -27,8 +27,8 @@ public class WhileTest {
 		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/While.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
 		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("While");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
--- a/test/bytecode/javFiles/Fac.jav
+++ b/test/bytecode/javFiles/Fac.jav
@ -2,7 +2,7 @@ import java.lang.Integer;
 import java.lang.Long;
 import java.lang.Double;
-public class Fac {
+public class Fac  {
 	getFac(n){
 		var res = 1;
--- a/test/bytecode/javFiles/Faculty.jav
+++ b/test/bytecode/javFiles/Faculty.jav
@ -1,13 +1,16 @@
-class Faculty {
+import java.lang.Integer;
-  Integer mul(Integer x, Integer y) {
+class Faculty {
  	return x;
   }
  m () {
   var fact = (Integer x) -> {
-        return mul(x, x);
+   	  //if (x == 1) {
        return x;
      //}
      //else {
        //return x * (fact.apply(x-1));
      //}
   };
   return fact;
  }
--- a/test/bytecode/javFiles/IfTest.jav
+++ b/test/bytecode/javFiles/IfTest.jav
@ -1,3 +1,6 @@
 import java.lang.Integer;
 import java.lang.Boolean;
 public class IfTest{
 	Integer m1(Boolean b) {
 		Integer i;
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@ -1,11 +1,16 @@
-import java.lang.Integer;
+import java.util.Vector;
 class Apply { } 
 public class Lambda {
  m () {
-   var lam1 = (Integer x) -> {
+   var lam1 = (x) -> {
        return x;
   };
-   return lam1;
+
   return lam1.apply(new Apply());
   //return lam1;
   //return new Vector();
  }
 }
--- a/test/bytecode/javFiles/Matrix.jav
+++ b/test/bytecode/javFiles/Matrix.jav
@ -2,24 +2,39 @@ import java.util.Vector;
 import java.lang.Integer;
 import java.lang.Boolean;
-class Matrix extends Vector<Vector<Integer>> {
+public class Matrix extends Vector<Vector<Integer>> {
-    mul(m) {
+   
 	Matrix () {
    }
 	Matrix(vv) {
    	Integer i;
    	i = 0;
 	  while(i < vv.size()) {
 //	    	Boolean a = this.add(vv.elementAt(i));
 		  this.add(vv.elementAt(i));
 		  i=i+1;
 	  }
    }
 	mul(m) {
        var ret = new Matrix();
        var i = 0;
        while(i < size()) {
-//            var v1 = this.elementAt(i);
+            var v1 = this.elementAt(i);
-//            var v2 = new Vector<Integer>();
+            var v2 = new Vector<Integer>();
-//            var j = 0;
+            var j = 0;
-//            while(j < v1.size()) {
+            while(j < v1.size()) {
-//                var erg = 0;
+                var erg = 0;
-//                var k = 0;
+                var k = 0;
-//                while(k < v1.size()) {
+                while(k < v1.size()) {
-//                    erg = erg + v1.elementAt(k)
+                    erg = erg + v1.elementAt(k)
-//                             * m.elementAt(k).elementAt(j);
+                             * m.elementAt(k).elementAt(j);
-//                    k++; }
+                    k++; }
 //                v2.addElement(new Integer(erg));
-//                j++; }
+                v2.addElement(erg);
-//            ret.addElement(v2);
+                j++; }
            ret.addElement(v2);
            i++; 
         }
        return ret;
--- a/test/bytecode/javFiles/OL.jav
+++ b/test/bytecode/javFiles/OL.jav
@ -1,18 +1,16 @@
 import java.lang.Integer;
-import java.lang.Double;  
+import java.lang.Double; 
-import java.lang.Boolean;
+import java.lang.String; 
 class OL {
-    m(x) { return x + x; }
+class OL     {
     m(x) { return x + x; }
-    //m(x) { return x || x; } 
+}
-	 
+    
 	}
-class Main {
+class OLMain   {
 	main(x) { 
 		var ol;
--- a/test/bytecode/javFiles/SubMatrix.jav
+++ b/test/bytecode/javFiles/SubMatrix.jav
@ -0,0 +1,3 @@
 public class SubMatrix extends Matrix {
 }
--- a/test/bytecode/javFiles/Tph.jav
+++ b/test/bytecode/javFiles/Tph.jav
@ -0,0 +1,11 @@
 public class Tph {
 	m(a,b){
 		var c = m2(b);
 		return a;
 	}
 	m2(b){
 		return b;
 	}
 }
--- a/test/bytecode/javFiles/Tph2.jav
+++ b/test/bytecode/javFiles/Tph2.jav
@ -0,0 +1,10 @@
 public class Tph2 {
 	m(a,b){
 		var c = m2(a,b);
 		return a;
 	}
 	m2(a,b){
 		return b;
 	}
 }
--- a/test/bytecode/javFiles/While.jav
+++ b/test/bytecode/javFiles/While.jav
@ -5,7 +5,7 @@ import java.lang.Integer;
 import java.lang.Long;
 public class While {
-	 m(x) {
+	 Integer m(x) {
 		while(x < 2) {
 			x = x+1;
 		}
--- a/test/javFiles/AddLong.jav
+++ b/test/javFiles/AddLong.jav
@ -2,7 +2,7 @@ import java.lang.Integer;
 import java.lang.Long;
 public class AddLong{
-		add(Integer a, Long b) {
+		 Long add(Integer a, Long b) {
    		Long c = a+b;
    		return c;
    	}
--- a/test/javFiles/Lambda.jav
+++ b/test/javFiles/Lambda.jav
@ -1,13 +1,12 @@
-import java.lang.Integer;
+class Apply { } 
 import java.lang.Number;
 public class Lambda {
  m () {
-   var lam1 = (x) -> {
+   var lam1 = (Integer x) -> {
        return x;
   };
-   return lam1;
+   return lam1.apply(new Apply());
  }
 }
--- a/test/javFiles/Matrix.jav
+++ b/test/javFiles/Matrix.jav
@ -16,7 +16,7 @@ class Matrix extends Vector<Vector<Integer>> {
                var k = 0;
                while(k < v1.size()) {
                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                  //  erg = add1(erg, mul1(v1.elementAt(k),
+                  //erg = add1(erg, mul1(v1.elementAt(k),
                  //           m.elementAt(k).elementAt(j)));
                    k++; }
                v2.addElement(new Integer(erg));
--- a/test/javFiles/Vector.jav
+++ b/test/javFiles/Vector.jav
@ -1,8 +1,23 @@
 import java.util.ArrayList;
 import java.util.Vector;
 import java.lang.Object;
 class MyVector{
 id(x){
-  return (x.elementAt(0));
+  Object i;
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  x.add(i);
  return x;
 }
 }
--- a/test/typeinference/UnifyTest.java
+++ b/test/typeinference/UnifyTest.java
@ -28,13 +28,20 @@ public class UnifyTest {
    public void finiteClosure() throws IOException, ClassNotFoundException {
        execute(new File(rootDirectory+"fc.jav"));
    }
-    */
+
 /*
    @Test
    public void lambda() throws IOException, ClassNotFoundException {
        execute(new File(rootDirectory+"Lambda.jav"));
    }
-*/
+
    */
    /*
    @Test
    public void vector() throws IOException, ClassNotFoundException {
        execute(new File(rootDirectory+"Vector.jav"));
    }
    */
    /*
    @Test
    public void lambda2() throws IOException, ClassNotFoundException {
@ -74,7 +81,6 @@ public class UnifyTest {
    }
 */
    @Test
    public void matrix() throws IOException, ClassNotFoundException {
        execute(new File(rootDirectory+"Matrix.jav"));
@ -82,6 +88,7 @@ public class UnifyTest {
    		//compiler.generateBytecode();
    }
 /*    
    @Test
    public void vector() throws IOException, ClassNotFoundException {
		`@ -0,0 +1,3 @@`
							`public class SubMatrix extends Matrix {`

							`}`