diff --git a/modeling/AVATAR/testMatteo.xml b/modeling/AVATAR/testMatteo.xml
index e28769f215eb2a9b0acbd7cd104dea0fe34a5816..86fafcbe43b1c4beb547465bdc2e08ca9b0930d9 100644
--- a/modeling/AVATAR/testMatteo.xml
+++ b/modeling/AVATAR/testMatteo.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<TURTLEGMODELING version="1.0beta" ANIMATE_INTERACTIVE_SIMULATION="true" ACTIVATE_PENALTIES="true" UPDATE_INFORMATION_DIPLO_SIM="true" ANIMATE_WITH_INFO_DIPLO_SIM="true" OPEN_DIAG_DIPLO_SIM="false" LAST_SELECTED_MAIN_TAB="1" LAST_SELECTED_SUB_TAB="1">
+<TURTLEGMODELING version="1.0beta" ANIMATE_INTERACTIVE_SIMULATION="true" ACTIVATE_PENALTIES="true" UPDATE_INFORMATION_DIPLO_SIM="true" ANIMATE_WITH_INFO_DIPLO_SIM="true" OPEN_DIAG_DIPLO_SIM="false" LAST_SELECTED_MAIN_TAB="1" LAST_SELECTED_SUB_TAB="4">
 
 <Modeling type="AVATAR Design" nameTab="Design1" tabs="Block Diagram$Main$P0$P2$P3$P1$DR" >
 <AVATARBlockDiagramPanel name="Block Diagram" minX="10" maxX="2500" minY="10" maxY="1500" zoom="1.0" >
diff --git a/src/main/java/avatartranslator/AvatarBlock.java b/src/main/java/avatartranslator/AvatarBlock.java
index b159cc322356be4a354bedf4374b634ae6872058..4ff2d674eb4fd398e85e339be42ffd89ede0fd16 100644
--- a/src/main/java/avatartranslator/AvatarBlock.java
+++ b/src/main/java/avatartranslator/AvatarBlock.java
@@ -195,6 +195,28 @@ public class AvatarBlock extends AvatarElement implements AvatarStateMachineOwne
         return sb.toString();
     }
 
+    public String toShortString() {
+        //Thread.currentThread().dumpStack();
+        StringBuffer sb = new StringBuffer("block:" + getName() + " ID=" + getID() + " \n");
+        if (getFather() != null) {
+            sb.append("  subblock of: " + getFather().getName() + " ID=" + getFather().getID()+ "\n");
+        } else {
+            sb.append("  top level block\n");
+        }
+        for(AvatarAttribute attribute: attributes) {
+            sb.append("  attribute: " + attribute.toString() + " ID=" + attribute.getID() + "\n");
+        }
+        for(AvatarMethod method: methods) {
+            sb.append("  method: " + method.toString() + " ID=" + method.getID() + "\n");
+        }
+        for(AvatarSignal signal: signals) {
+            sb.append("  signal: " + signal.toString() + " ID=" + signal.getID() + "\n");
+        }
+
+
+        return sb.toString();
+    }
+
     public int attributeNb() {
         return attributes.size();
     }
diff --git a/src/main/java/avatartranslator/AvatarBlockTemplate.java b/src/main/java/avatartranslator/AvatarBlockTemplate.java
index 80bf36053b525d3ce68ab5f64f6ff6cbeb30650d..92190d2e333b72366debc0d1102e994735f3b40e 100644
--- a/src/main/java/avatartranslator/AvatarBlockTemplate.java
+++ b/src/main/java/avatartranslator/AvatarBlockTemplate.java
@@ -389,7 +389,7 @@ public class AvatarBlockTemplate {
         at.setGuard("duration>0");
         at = makeAvatarEmptyTransitionBetween(ab, asm, stepRead, activatedState, _refB);
         at.setDelays("2", "2");
-        at.addAction("durattion=duration-step");
+        at.addAction("duration = duration - step");
 
         // Preempted
         AvatarActionOnSignal preemptRead = new AvatarActionOnSignal("read_" + preemptP.getSignalName(), preemptP, _refB);
@@ -431,7 +431,7 @@ public class AvatarBlockTemplate {
         AvatarSignal stepP = new AvatarSignal("stepP", AvatarSignal.IN, _refB);
         AvatarAttribute att1 = new AvatarAttribute("step", AvatarType.INTEGER, ab, _refB);
         stepP.addParameter(att1);
-        AvatarSignal deactivatedP = new AvatarSignal("deactivated", AvatarSignal.IN, _refB);
+        AvatarSignal deactivatedP = new AvatarSignal("deactivatedP", AvatarSignal.IN, _refB);
         AvatarSignal reactivatedP = new AvatarSignal("reactivatedP", AvatarSignal.IN, _refB);
         AvatarSignal finishP = new AvatarSignal("finishP", AvatarSignal.OUT, _refB);
 
@@ -509,6 +509,7 @@ public class AvatarBlockTemplate {
 
         // Making a step
         AvatarActionOnSignal stepRead = new AvatarActionOnSignal("read_" + stepP.getSignalName(), stepP, _refB);
+        stepRead.addValue("step");
         asm.addElement(stepRead);
         at = makeAvatarEmptyTransitionBetween(ab, asm, activatedState, stepRead, _refB);
         at.setGuard("duration>0");
@@ -555,7 +556,7 @@ public class AvatarBlockTemplate {
 
 
         // Create attributes
-        AvatarAttribute h = new AvatarAttribute("duration", AvatarType.INTEGER, ab, _refB);
+        AvatarAttribute h = new AvatarAttribute("h", AvatarType.INTEGER, ab, _refB);
         h.setInitialValue("" + 0);
         ab.addAttribute(h);
 
@@ -581,12 +582,14 @@ public class AvatarBlockTemplate {
         // Tick
         AvatarActionOnSignal aaosWrite = new AvatarActionOnSignal("sendTickIn_" + tick.getSignalName(), tick, _refB);
         asm.addElement(aaosWrite);
+        aaosWrite.addValue("step");
         at = makeAvatarEmptyTransitionBetween(ab, asm, mainState, aaosWrite, _refB);
         at = makeAvatarEmptyTransitionBetween(ab, asm, aaosWrite, mainState, _refB);
-        at.addAction("h=h+step");
+        at.addAction("h = h + step");
 
         // finished
         aaosWrite = new AvatarActionOnSignal("sendAllFinished_" + allFinished.getSignalName(), allFinished, _refB);
+        aaosWrite.addValue("h");
         asm.addElement(aaosWrite);
         at = makeAvatarEmptyTransitionBetween(ab, asm, mainState, aaosWrite, _refB);
 
@@ -600,7 +603,7 @@ public class AvatarBlockTemplate {
 
 
     // Still to be added: main blocks
-    public static AvatarBlock getClockGraphBlock(String _name, AvatarSpecification _avspec, Object _refB,
+    public static AvatarBlock getMainGraphBlock(String _name, AvatarSpecification _avspec, Object _refB,
                                                  Vector<String> swTasks, Vector<String> hwTasks, Vector<String> hwSizes,
                                                  String tickS, String allFinishedS, int nbCoresV, int durationDRV,
                                                  int HWSize) {
@@ -655,7 +658,7 @@ public class AvatarBlockTemplate {
         AvatarAttribute step = new AvatarAttribute("step", AvatarType.INTEGER, ab, _refB);
         ab.addAttribute(step);
 
-        AvatarAttribute nbHW = new AvatarAttribute("nbHW", AvatarType.INTEGER, ab, _refB);
+        AvatarAttribute nbHW = new AvatarAttribute("allocHW", AvatarType.INTEGER, ab, _refB);
         nbHW.setInitialValue("" + HWSize);
         ab.addAttribute(nbHW);
 
@@ -740,6 +743,7 @@ public class AvatarBlockTemplate {
             } else {
                 as = allFinished;
                 AvatarActionOnSignal allFinishedRead = new AvatarActionOnSignal("read_" + as.getSignalName(), as, _refB);
+                allFinishedRead.addValue("finalClockValue");
                 asm.addElement(allFinishedRead);
 
                 at = makeAvatarEmptyTransitionBetween(ab, asm, finishedHWRead, allFinishedRead, _refB);
@@ -751,20 +755,167 @@ public class AvatarBlockTemplate {
                 asm.addElement(stop);
                 at = makeAvatarEmptyTransitionBetween(ab, asm, allFinishedRead, stop, _refB);
             }
+            cpt ++;
+
+        }
+
+        // evaluateSW state
+        AvatarState evaluateSW = new AvatarState("evaluateSW", _refB);
+        asm.addElement(evaluateSW);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, finishHW, evaluateSW, _refB);
+        at.setDelays("1", "1");
+
+
+        // preemptSW state
+        AvatarState preemptSW = new AvatarState("preemptSW", _refB);
+        asm.addElement(preemptSW);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, evaluateSW, preemptSW, _refB);
+        at.setGuard("(allocCore > 0) && (rescheduleSW)");
+        at.addAction("allocCore = 0");
+
+        for(String task: swTasks) {
+            as = ab.getAvatarSignalWithName("preempt_" + task);
+            AvatarActionOnSignal preemptSWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB);
+            asm.addElement(preemptSWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSW, preemptSWWrite, _refB);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSWWrite, preemptSW, _refB);
+        }
+
+
+
+        // selectSW state
+        AvatarState selectSW = new AvatarState("selectSW", _refB);
+        asm.addElement(selectSW);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSW, selectSW, _refB);
+        at.setDelays("1", "1");
+        at = makeAvatarEmptyTransitionBetween(ab, asm, evaluateSW, selectSW, _refB);
+        at.setGuard("else");
+
+        for(String task: swTasks) {
+            as = ab.getAvatarSignalWithName("select_" + task);
+            AvatarActionOnSignal selectSWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB);
+            asm.addElement(selectSWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, selectSWWrite, _refB);
+            at.setGuard("allocCore < nbCores");
+            at = makeAvatarEmptyTransitionBetween(ab, asm, selectSWWrite, selectSW, _refB);
+            at.addAction("allocCore = allocCore + 1");
+        }
+
+        // selectHW state
+        AvatarState selectHW = new AvatarState("selectHW", _refB);
+        asm.addElement(selectHW);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, selectHW, _refB);
+        at.setDelays("2", "2");
+        at.setGuard("currentDR == 0");
+
+        cpt = 0;
+        for(String task: hwTasks) {
+            as = ab.getAvatarSignalWithName("select_" + task);
+            AvatarActionOnSignal selectHWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB);
+            asm.addElement(selectHWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, selectHWWrite, _refB);
+            at.setGuard("remainHW > " + hwSizes.get(cpt));
+
+            at = makeAvatarEmptyTransitionBetween(ab, asm, selectHWWrite, selectHW, _refB);
+            at.addAction("runningHW = runningHW + 1");
+            at.addAction("allocHW = allocHW + " + hwSizes.get(cpt));
+            at.addAction("remainHW = remainHW - " + hwSizes.get(cpt));
+            cpt ++;
+        }
 
+        // blockNonSelected state
+        AvatarState blockNonSelected = new AvatarState("blockNonSelected", _refB);
+        asm.addElement(blockNonSelected);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, blockNonSelected, _refB);
+        at.setGuard("runningHW> 0 ");
 
+        for(String task: hwTasks) {
+            as = ab.getAvatarSignalWithName("deactivate_" + task);
+            AvatarActionOnSignal deactivateHWWrite = new AvatarActionOnSignal("deactivate_" + as.getSignalName(), as, _refB);
+            asm.addElement(deactivateHWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, deactivateHWWrite, _refB);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, deactivateHWWrite, blockNonSelected, _refB);
+        }
 
+        // startDR state
+        AvatarState startDR = new AvatarState("startDR", _refB);
+        asm.addElement(startDR);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, startDR, _refB);
+        at.setGuard("(runningHW == 0) && (allocHW > 0)");
 
 
+        // unblockAllHWP state
+        AvatarState unblockAllHWP = new AvatarState("unblockAllHWP", _refB);
+        asm.addElement(unblockAllHWP);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, startDR, unblockAllHWP, _refB);
+        at.addAction("currentDR = durationDR");
+        at.addAction("allocHW = 0");
+        at.addAction("remainHW = nbHW");
+
+
+        for(String task: hwTasks) {
+            as = ab.getAvatarSignalWithName("reactivate_" + task);
+            AvatarActionOnSignal reactivateHWWrite = new AvatarActionOnSignal("reactivate_" + as.getSignalName(), as, _refB);
+            asm.addElement(reactivateHWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, unblockAllHWP, reactivateHWWrite, _refB);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, reactivateHWWrite, unblockAllHWP, _refB);
         }
 
+        // makeStep state
+        AvatarState makeStep = new AvatarState("makeStep", _refB);
+        asm.addElement(makeStep);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, makeStep, _refB);
+        at.setGuard("nbHWTasks == 0");
+        at.setDelays("1", "1");
 
+        at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, makeStep, _refB);
+        at.setDelays("1", "1");
 
+        at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, makeStep, _refB);
+        at.setDelays("1", "1");
+
+        // makeSteps state
+        AvatarState makeSteps = new AvatarState("makeSteps", _refB);
+        asm.addElement(makeSteps);
+        AvatarActionOnSignal tickRead = new AvatarActionOnSignal(tick.getSignalName(), tick, _refB);
+        tickRead.addValue("step");
+        asm.addElement(tickRead);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, makeStep, tickRead, _refB);
+        at = makeAvatarEmptyTransitionBetween(ab, asm, tickRead, makeSteps, _refB);
+
+        for(String task: swTasks) {
+            as = ab.getAvatarSignalWithName("step_" + task);
+            AvatarActionOnSignal stepSWWrite = new AvatarActionOnSignal("step_" + as.getSignalName(), as, _refB);
+            stepSWWrite.addValue("step");
+            asm.addElement(stepSWWrite);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, stepSWWrite, _refB);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, stepSWWrite, makeSteps, _refB);
+        }
 
+        for(String task: hwTasks) {
+            as = ab.getAvatarSignalWithName("step_" + task);
+            AvatarActionOnSignal stepHWWrite = new AvatarActionOnSignal("step_" + as.getSignalName(), as, _refB);
+            asm.addElement(stepHWWrite);
+            stepHWWrite.addValue("step");
+            at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, stepHWWrite, _refB);
+            at = makeAvatarEmptyTransitionBetween(ab, asm, stepHWWrite, makeSteps, _refB);
+        }
 
+        // waitForSteps state
+        AvatarState waitForSteps = new AvatarState("waitForSteps", _refB);
+        asm.addElement(waitForSteps);
 
+        at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, waitForSteps, _refB);
+        at.setDelays("1", "1");
+        at.setGuard("currentDR == 0");
 
+        at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, waitForSteps, _refB);
+        at.setDelays("1", "1");
+        at.setGuard("currentDR > 0");
+        at.addAction("currentDR = currentDR - step");
 
+        at = makeAvatarEmptyTransitionBetween(ab, asm, waitForSteps, finishSW, _refB);
+        at.setDelays("2", "2");
 
         return ab;
     }
diff --git a/src/main/java/avatartranslator/AvatarRelation.java b/src/main/java/avatartranslator/AvatarRelation.java
index 1e7ba948363802daaf5735278aee5a0fefeb433b..319df8bae0847f72ce5a373ba69f356cac8e2939 100644
--- a/src/main/java/avatartranslator/AvatarRelation.java
+++ b/src/main/java/avatartranslator/AvatarRelation.java
@@ -205,7 +205,11 @@ public class AvatarRelation extends AvatarElement {
             if (i>0) {
                 sb.append(" ; ");
             }
-            sb.append(block1.getName() + "." + signals1.get(i).getName() + "=" + block2.getName() + "." + signals2.get(i).getName());
+            if ((signals1.get(i) == null) || (signals2.get(i) == null)) {
+                sb.append(block1.getName() + "." + "NULL" + "=" + block2.getName() + "." + "NULL");
+            } else {
+                sb.append(block1.getName() + "." + signals1.get(i).getName() + "=" + block2.getName() + "." + signals2.get(i).getName());
+            }
         }
         return sb.toString();
     }
diff --git a/src/main/java/avatartranslator/AvatarSpecification.java b/src/main/java/avatartranslator/AvatarSpecification.java
index cbb51f59091a64374e8f49d1091f6ca1cb82f24c..2c60c5ced5001c250912f64a2dc63425ec944fd7 100644
--- a/src/main/java/avatartranslator/AvatarSpecification.java
+++ b/src/main/java/avatartranslator/AvatarSpecification.java
@@ -250,6 +250,25 @@ public class AvatarSpecification extends AvatarElement {
 		return sb.toString();
     }
 
+
+    public String toShortString() {
+        //TraceManager.addDev("To Short String");
+        //Thread.currentThread().dumpStack();
+        StringBuffer sb = new StringBuffer("Blocks:\n");
+        for(AvatarBlock block: blocks) {
+            sb.append("*** " + block.toShortString()+"\n");
+        }
+        sb.append("\nRelations:\n");
+        for(AvatarRelation relation: relations) {
+            sb.append("Relation:" + relation.toString() + "\n");
+        }
+        /*for (AvatarConstant constant: constants){
+            sb.append("Constant:" + constant.toString() + "\n");
+        }*/
+
+        return sb.toString();
+    }
+
     public AvatarBlock getBlockWithName(String _name) {
         for(AvatarBlock block: blocks) {
             if (block.getName().compareTo(_name)== 0) {
diff --git a/src/main/java/cli/BF.java b/src/main/java/cli/BF.java
new file mode 100644
index 0000000000000000000000000000000000000000..797f72e3c6a7b47236e09272e8c209aa2e2e83e8
--- /dev/null
+++ b/src/main/java/cli/BF.java
@@ -0,0 +1,357 @@
+/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+ * 
+ * ludovic.apvrille AT enst.fr
+ * 
+ * This software is a computer program whose purpose is to allow the
+ * edition of TURTLE analysis, design and deployment diagrams, to
+ * allow the generation of RT-LOTOS or Java code from this diagram,
+ * and at last to allow the analysis of formal validation traces
+ * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+ * from INRIA Rhone-Alpes.
+ * 
+ * This software is governed by the CeCILL  license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ * 
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ * 
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * 
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ */
+
+
+package cli;
+
+//import com.sun.deploy.trace.Trace;
+import common.ConfigurationTTool;
+import launcher.RTLLauncher;
+import myutil.Conversion;
+import myutil.IntExpressionEvaluator;
+import myutil.PluginManager;
+import myutil.TraceManager;
+import ui.MainGUI;
+import ui.util.IconManager;
+import avatartranslator.*;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.BitSet;
+import java.util.*;
+
+
+/**
+ * Class Set
+ * Creation: 19/03/2019
+ * Version 2.0 19/03/2019
+ *
+ * @author Ludovic APVRILLE
+ */
+public class BF extends Command  {
+
+
+    public BF() {
+
+    }
+
+    public List<Command> getListOfSubCommands() {
+        return subcommands;
+    }
+
+    public String getCommand() {
+        return "bruteforce";
+    }
+
+    public String getShortCommand() {
+        return "bf";
+    }
+
+    public String getUsage() { return "bf <graphfile> <nbOfCLBs> <durationDynamicReconfiguration> <nbOfCores>"; }
+
+    public String getDescription() { return "Bruteforcing FPGA and SW scheduling. Reserved for Development purpose"; }
+
+    public String getExample() {
+        return "bf graph.txt 100 30 2";
+    }
+
+
+    public  String executeCommand(String command, Interpreter interpreter) {
+        int cpt = 0;
+        try {
+
+            TraceManager.addDev("BF checking attributes");
+
+            // Check attributes
+            String[] commands = command.split(" ");
+            if (commands.length < 4) {
+                return Interpreter.BAD;
+            }
+
+            String fileName = commands[0];
+
+            if (fileName.length() < 1) {
+                return Interpreter.BAD_FILE_NAME;
+            }
+
+
+
+            int nbOfCLBs = Integer.decode(commands[1]);
+            int dynamicReconfigurationTime = Integer.decode(commands[2]);
+            int nbOfCores = Integer.decode(commands[3]);
+
+
+            if (nbOfCLBs < 1) {
+                return Interpreter.BAD;
+            }
+
+            if (dynamicReconfigurationTime < 1) {
+                return Interpreter.BAD;
+            }
+
+
+            if (nbOfCores < 1) {
+                return Interpreter.BAD;
+            }
+
+
+            // Read text file
+            TraceManager.addDev("Reading file");
+            File f = new File(fileName);
+            cpt = 1;
+            int inSWTask = 0;
+            int inHWTask = 0;
+            Vector<BFTask> tasks = new Vector<>();
+            BFTask t = null;
+            int taskIndex = 0;
+
+            try(BufferedReader br = new BufferedReader(new FileReader(fileName))) {
+                for(String line; (line = br.readLine()) != null; ) {
+                    cpt ++;
+                    if (line.length() > 0) {
+
+                        // Graph structure
+                        if (line.contains("-")) {
+                            // link between tasks
+                            int indexMinus = line.indexOf("-");
+                            String originTaskName =  line.substring(0, indexMinus).trim();
+                            String []nextTasks = line.substring(indexMinus+1, line.length()).trim().split(" ");
+
+                            //TraceManager.addDev("origin task:" + originTaskName);
+                            BFTask originTask = getBFTaskByName(tasks, originTaskName);
+                            if (originTask == null) {
+                                return Interpreter.BAD_FILE;
+                            }
+
+                            for(String taskName: nextTasks) {
+                                //TraceManager.addDev("destination task:" + taskName);
+                                BFTask destinationTask = getBFTaskByName(tasks, taskName);
+                                if (destinationTask == null) {
+                                    return Interpreter.BAD_FILE;
+                                }
+                                originTask.addNext(destinationTask);
+                                destinationTask.addPrevious(originTask);
+                            }
+
+
+                        //Task definition
+                        } else {
+                            if (t == null) {
+                                // new task
+                                t = new BFTask(line);
+                                tasks.add(t);
+                                taskIndex = 1;
+                            } else {
+                                if (taskIndex == 1) {
+                                    // hw or sw?
+                                    if (line.compareTo("hw") == 0) {
+                                        t.type = 0;
+                                    } else {
+                                        t.type = 1;
+                                    }
+                                } else {
+                                    // extra info
+                                    int info = Integer.decode(line);
+                                    switch (taskIndex){
+                                        case 2:
+                                            if (t.isSW()) {
+                                                t.timing = info;
+                                                t = null;
+                                            } else {
+                                                t.clb = info;
+                                            }
+                                            break;
+                                        case 3:
+                                            t.dsp = info;
+                                            break;
+                                        case 4:
+                                            t.mem = info;
+                                            break;
+                                        case 5:
+                                            t.timing = info;
+                                            t = null;
+                                    }
+                                }
+
+                                if (t != null) {
+                                    taskIndex ++;
+                                }
+
+                            }
+                        }
+                    }
+
+                }
+
+            }
+
+            TraceManager.addDev("File read");
+
+            // Print all tasks
+            TraceManager.addDev("Tasks:");
+            for (BFTask ta: tasks) {
+                TraceManager.addDev(ta.toString());
+            }
+
+            // Generate AvatarSpec
+            AvatarSpecification avspec = new AvatarSpecification(fileName, this);
+
+            // tasks -> blocks
+            for(BFTask bft: tasks) {
+                bft.makeBlock(avspec);
+                avspec.addBlock(bft.block);
+            }
+
+            // Clock
+            TraceManager.addDev("Making clock block");
+            AvatarBlock clockBlock = AvatarBlockTemplate.getClockGraphBlock("Clock", avspec, this, 1, "tick",
+                    "allFinished");
+            avspec.addBlock(clockBlock);
+
+            // Main block
+            TraceManager.addDev("Making main block");
+            Vector<String> swTasks = new Vector<>();
+            Vector<String> hwTasks = new Vector<>();
+            Vector<String> hwSizes = new Vector<>();
+            for(BFTask bft: tasks) {
+                if (bft.isHW()) {
+                    hwTasks.add(bft.name);
+                    hwSizes.add(""+bft.clb);
+                } else {
+                    swTasks.add(bft.name);
+                }
+            }
+
+            AvatarBlock mainBlock = AvatarBlockTemplate.getMainGraphBlock("Main", avspec, this,
+                    swTasks, hwTasks, hwSizes, "tick",
+                    "allFinished", nbOfCores, dynamicReconfigurationTime, nbOfCLBs);
+            avspec.addBlock(mainBlock);
+
+            // Relations
+            TraceManager.addDev("Making relations 1");
+            AvatarRelation ar = new AvatarRelation("rMainClock", clockBlock, mainBlock, this);
+            ar.addSignals(clockBlock.getAvatarSignalWithName("tick"), mainBlock.getAvatarSignalWithName("tick"));
+            ar.addSignals(clockBlock.getAvatarSignalWithName("allFinished"), mainBlock.getAvatarSignalWithName("allFinished"));
+            avspec.addRelation(ar);
+
+            TraceManager.addDev("Making relations 2");
+
+            for(BFTask bft: tasks) {
+                TraceManager.addDev("Dealing with btf=" + bft.name);
+                // Relation between this block and the main block
+                AvatarBlock b = bft.block;
+                ar = new AvatarRelation("r" + bft.name + "Main", b, mainBlock, this);
+                avspec.addRelation(ar);
+                TraceManager.addDev("Making relations 2.1 for " + bft.name);
+                AvatarSignal as1 = b.getAvatarSignalWithName("selectP");
+                AvatarSignal as2 = mainBlock.getAvatarSignalWithName("select_" + bft.name);
+                ar.addSignals(as1, as2);
+                as1 = b.getAvatarSignalWithName("stepP");
+                as2 = mainBlock.getAvatarSignalWithName("step_" + bft.name);
+                ar.addSignals(as1, as2);
+                TraceManager.addDev("Making relations 2.3");
+                as1 = b.getAvatarSignalWithName("finishP");
+                as2 = mainBlock.getAvatarSignalWithName("finished_" + bft.name);
+                ar.addSignals(as1, as2);
+                if (bft.isHW()) {
+                    TraceManager.addDev("Making relations 2.4.1");
+                    as1 = b.getAvatarSignalWithName("deactivatedP");
+                    as2 = mainBlock.getAvatarSignalWithName("deactivate_" + bft.name);
+                    ar.addSignals(as1, as2);
+                    TraceManager.addDev("Making relations 2.4.2");
+                    as1 = b.getAvatarSignalWithName("reactivatedP");
+                    if (as1 == null) {
+                        TraceManager.addDev("Null as1");
+                    }
+                    as2 = mainBlock.getAvatarSignalWithName("reactivate_" + bft.name);
+                    if (as2 == null) {
+                        TraceManager.addDev("Null as2");
+                    }
+                    ar.addSignals(as1, as2);
+                    TraceManager.addDev("Done Making relations 2.4.2");
+                } else {
+                    TraceManager.addDev("Making relations 2.5");
+                    as1 = b.getAvatarSignalWithName("preemptP");
+                    as2 = mainBlock.getAvatarSignalWithName("preempt_" + bft.name);
+                    ar.addSignals(as1, as2);
+                }
+
+
+                TraceManager.addDev("Done making relations 2.1 for " + bft.name);
+                // Relation between this block and its next
+
+            }
+
+            TraceManager.addDev("All done :)");
+
+
+            // Printing avspec
+            TraceManager.addDev("\n\n**************** AVSPEC:\n" + avspec.toShortString() + "\n*********\n\n");
+
+
+            // Compte RG
+
+            // Deduce best scheduling
+
+
+
+
+            return null;
+        } catch (Exception e) {
+            TraceManager.addDev("Exception: " + e.getMessage());
+            return "BF failed";
+
+        }
+
+    }
+
+    public void fillSubCommands() {
+
+    }
+
+    private BFTask getBFTaskByName(Vector<BFTask> list, String name) {
+        for(BFTask t: list) {
+            if (t.name.compareTo(name) == 0) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+}
diff --git a/src/main/java/cli/Interpreter.java b/src/main/java/cli/Interpreter.java
index 420044b77dfe96e3e7cab4d13b30f5c2072ed1a8..c8f5b31b3828698c678aa4a84ce5f12655084415 100644
--- a/src/main/java/cli/Interpreter.java
+++ b/src/main/java/cli/Interpreter.java
@@ -59,7 +59,7 @@ import java.util.Vector;
 public class Interpreter implements Runnable, TerminalProviderInterface {
 
     public final static Command[] commands = {new Action(), new Help(), new History(), new Print(), new Quit(),
-            new TestSpecific(), new TML(), new Set(), new Wait(), new Robot()};
+            new TestSpecific(), new TML(), new Set(), new Wait(), new Robot(), new BF()};
 
     // Errors
     public final static String UNKNOWN = "Unknown command";
@@ -72,6 +72,8 @@ public class Interpreter implements Runnable, TerminalProviderInterface {
     public final static String TTOOL_ALREADY_STARTED = "TTool is already started. Cannot execute command.";
     public final static String BAD_COMMAND_NAME = "The provided command is invalid";
     public final static String ROBOT_EXCEPTION = "Robot could not be started";
+    public final static String BAD_FILE_NAME = "Unvalid file identifier";
+    public final static String BAD_FILE = "Badly formatted file";
 
 
     private String script;
@@ -109,7 +111,9 @@ public class Interpreter implements Runnable, TerminalProviderInterface {
         String line;
         currentLine = 0;
         while ((line = term.getNextCommand()) != null) {
+            //TraceManager.addDev("Dealing with line: " + line);
             for(String subCommand: line.split(";")) {
+                //TraceManager.addDev("Executing: " + subCommand);
                 executeLine(subCommand, currentLine, false);
             }
             currentLine++;
@@ -145,8 +149,9 @@ public class Interpreter implements Runnable, TerminalProviderInterface {
         while (scanner.hasNextLine()) {
             String line = scanner.nextLine();
             currentLine++;
-
+            //TraceManager.addDev("Dealing with line: " + line);
             for(String subCommand: line.split(";")) {
+                //TraceManager.addDev("Executing: " + subCommand);
                 executeLine(subCommand, currentLine, true);
             }