diff --git a/sablecc/sablecc.jar b/sablecc/sablecc.jar
new file mode 100644
index 0000000000000000000000000000000000000000..a6187d566eb5524116975e8e2ff324eafe1762c6
Binary files /dev/null and b/sablecc/sablecc.jar differ
diff --git a/sablecc/sablecc_thesis.pdf b/sablecc/sablecc_thesis.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c76b634d006c34214caf5df1587f598d652480ed
Binary files /dev/null and b/sablecc/sablecc_thesis.pdf differ
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..871caa1526ad40a35eb85fb1032681e585fa4fba
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,4 @@
+*\.class
+*/*\.class
+*/*/*\.class
+*~
\ No newline at end of file
diff --git a/src/C3aVM.java b/src/C3aVM.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8bb3410c1eda526ffc8aae1f831508bfb67fcca
--- /dev/null
+++ b/src/C3aVM.java
@@ -0,0 +1,67 @@
+import java.io.IOException;
+import c3a.C3a;
+import c3a.C3aEval;
+import c3a.LoadC3a;
+import ts.Ts;
+import ts.TsParser;
+
+public class C3aVM {
+    private int verboseLevel = 0;
+    private TsParser stParser;
+    private String symbolsTableFileName;
+    private String C3AFileName;
+    private int stackSize;
+	private C3a code;
+	private Ts globalTable;
+	private LoadC3a loadC3a;
+    
+    public C3aVM(String symbolsTableFileName, String C3AFileName, int stackSize, int verboseLevel){
+	this.stackSize = stackSize;
+	this.verboseLevel = verboseLevel;
+	this.symbolsTableFileName = symbolsTableFileName;
+	this.C3AFileName = C3AFileName;
+	stParser = new TsParser();
+	this.globalTable = stParser.parse(symbolsTableFileName);
+	loadC3a = new LoadC3a(C3AFileName, this.globalTable);
+	this.code = loadC3a.getC3a();
+    }
+    
+    
+    public void run() throws IOException {
+	if(verboseLevel > 0)
+	    code.affiche(null);
+	C3aEval c3aEval = new C3aEval(code, globalTable, stackSize, verboseLevel);
+	code.accept(c3aEval);
+	c3aEval.affiche(null);
+	//        eval.affiche(C3AFileName.substring(0, C3AFileName.length() - 4));
+
+    }
+
+    public static void main(String[] args){
+	int verboseLevel = 0;
+	String symbolsTableFileName = null;
+	String C3AFileName = null;
+	int stackSize = 10000;
+
+        try {
+	    for (int i = 0; i < args.length; i++) {
+		if(args[i].equals("-v"))
+		    verboseLevel = Integer.parseInt(args[++i]);
+		else if(args[i].equals("-s"))
+		    stackSize = Integer.parseInt(args[++i]);
+		else if(args[i].equals("-c3a"))
+		    C3AFileName = args[++i];
+		else if(args[i].equals("-ts"))
+		    symbolsTableFileName = args[++i];
+	    }
+	    if(C3AFileName == null || symbolsTableFileName == null){
+		System.out.println("java C3aVM -c3a C3AFile -ts TSFile -s stackSize -v verboseLevel");
+		System.exit(1);
+	    }
+	    C3aVM vm = new C3aVM(symbolsTableFileName, C3AFileName, stackSize, verboseLevel);
+	    vm.run();
+	}catch(IOException e){
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/src/Compiler.java b/src/Compiler.java
new file mode 100644
index 0000000000000000000000000000000000000000..39aebb826badfb5cf6e1f659e38d62a28e717f9a
--- /dev/null
+++ b/src/Compiler.java
@@ -0,0 +1,215 @@
+import lParser.parser.*;
+import lParser.lexer.*;
+import lParser.node.*;
+import java.io.*;
+import sc.*;
+import sa.*;
+import ts.*;
+import c3a.*;
+import nasm.*;
+import fg.*;
+import ig.*;
+import util.Error;
+
+
+public class Compiler
+{
+	private static String baseName = null;
+	private static String inputFileName = null;
+	private static int verboseLevel = 0;
+	private static Start scRoot = null;
+	private static SaProg saRoot = null;
+	private static Ts tableGlobale = null;
+	private static C3a c3a = null;
+	private static Nasm nasm = null;
+	private static Fg flowGraph = null;
+	private static FgSolution flowGraphSolution = null;
+	private static Ig interferenceGraph = null;
+
+
+	public static void main(String[] args) {
+		processCommandLine(args);
+		System.out.println("[BUILD SC] ");
+		buildSc();
+		/*		System.out.println("[BUILD SA] ");
+		buildSa();
+		System.out.println("[BUILD TS] ");
+		buildTs();
+		System.out.println("[TYPE CHECKING]");
+		typeCheck();
+		System.out.println("[BUILD C3A] ");
+		buildC3a();
+		System.out.println("[BUILD PRE NASM] ");
+		buildPreNasm();
+		System.out.println("[BUILD FLOW GRAPH] ");
+		buildFg();
+		System.out.println("[SOLVE FLOW GRAPH]");
+		solveFg();
+		System.out.println("[BUILD INTERFERENCE GRAPH] ");
+		buildIg();
+		System.out.println("[ALLOCATE REGISTERS]");
+		interferenceGraph.allocateRegisters();
+		System.out.println("[PRINT NASM]");
+		nasm.afficheNasm(baseName);
+		System.exit(Error.NOERROR.code());*/
+	}
+
+	private static void processCommandLine(String[] args) {
+		for (int i = 0; i < args.length; i++) {
+			if (args[i].equals("-v")) {
+				verboseLevel = Integer.parseInt(args[++i]);
+			} else {
+				inputFileName = args[i];
+				baseName = removeSuffix(inputFileName, ".l");
+			}
+		}
+		if (inputFileName == null) {
+			System.out.println("java Compiler input_file -v verbose_level");
+			System.exit(1);
+		}
+	}
+
+	private static void buildSc() {
+		PushbackReader fileReader = null;
+		Parser parser = null;
+		try {
+			fileReader = new PushbackReader(new FileReader(inputFileName));
+		} catch (IOException e) {
+			System.err.println("cannot open input file");
+			e.printStackTrace();
+		}
+		try {
+			parser = new Parser(new Lexer(fileReader));
+			scRoot = parser.parse();
+		} catch (ParserException e) {
+			System.err.println("syntax error");
+			e.printStackTrace();
+			System.exit(Error.SYNT.code());
+		} catch (LexerException e) {
+			System.err.println("lexical error");
+			e.printStackTrace();
+			System.exit(Error.LEX.code());
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT SC]");
+			scRoot.apply(new Sc2Xml(baseName));
+		}
+	}
+
+	private static void buildSa() {
+		try {
+			Sc2sa sc2sa = new Sc2sa();
+			scRoot.apply(sc2sa);
+			saRoot = sc2sa.getRoot();
+		} catch (Exception ignored) {
+		}
+		PrintStream out = System.out;
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT SA]");
+			try {
+				out = new PrintStream(baseName + ".sa");
+			}
+			catch (IOException e) {
+				System.err.println("Error: " + e.getMessage());
+			}
+			out.println(saRoot);
+			//new Sa2Xml(saRoot, baseName);
+		}
+	}
+
+	private static void buildTs() {
+		try {
+			Sa2ts sa2ts = new Sa2ts();
+			saRoot.accept(sa2ts);
+			tableGlobale = sa2ts.getTableGlobale();
+			SaCheckLinkage saCheckLinkage = new SaCheckLinkage();
+			saCheckLinkage.visit(saRoot);
+			if (tableGlobale.getFct("main") == null)
+				throw new ErrorException(Error.TS, "la fonction main n'est pas définie");
+		} catch (ErrorException e) {
+			System.err.print("ERREUR TABLE DES SYMBOLES : ");
+			System.err.println(e.getMessage());
+			System.exit(e.getCode());
+		} catch (Exception ignored) {
+		}
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT TS]");
+			tableGlobale.afficheTout(baseName);
+		}
+	}
+
+	private static void typeCheck() {
+		new SaTypeCheck(saRoot);
+	}
+
+	private static void buildC3a() {
+		try{
+			Sa2c3a sa2c3a = new Sa2c3a(saRoot, tableGlobale);
+			saRoot.accept(sa2c3a);
+			c3a = sa2c3a.getC3a();
+		}
+		catch(Exception e){}
+
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT C3A] ");
+			c3a.affiche(baseName);
+		}
+	}
+
+	private static void buildPreNasm() {
+		C3a2nasm c3a2nasm = new C3a2nasm(c3a, tableGlobale);
+		c3a.accept(c3a2nasm);
+		nasm = c3a2nasm.getNasm();
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT PRE NASM] ");
+			nasm.affichePreNasm(baseName);
+		}
+	}
+
+
+	private static void buildFg() {
+		flowGraph = new Fg(nasm);
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT FLOW GRAPH] ");
+			flowGraph.affiche(baseName);
+		}
+	}
+
+	private static void solveFg() {
+		flowGraphSolution = new FgSolution(nasm, flowGraph);
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT FLOW GRAPH SOLUTION] ");
+			flowGraphSolution.affiche(baseName);
+		}
+	}
+
+	private static void buildIg() {
+		interferenceGraph = new Ig(flowGraphSolution);
+		if (verboseLevel > 1) {
+			System.out.println("[PRINT INTERFERENCE GRAPH] ");
+			interferenceGraph.affiche(baseName);
+		}
+	}
+
+
+
+	/*catch (Exception e)
+	{
+		e.printStackTrace();
+		System.out.println(e.getMessage());
+		System.exit(1);
+	}
+    }*/
+
+
+    public static String removeSuffix(final String s, final String suffix)
+    {
+		if (s != null && suffix != null && s.endsWith(suffix)){
+			return s.substring(0, s.length() - suffix.length());
+		}
+		return s;
+    }
+
+}
diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..b64a54cfb52d4ed71cb744d8ded611b48cd6b86c
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,52 @@
+all: Compiler C3aVM NasmVM SaVM
+
+SaVM: SaVM.java saParser
+	javac SaVM.java
+
+NasmVM.jar : NasmVM
+	jar cmf NasmVM.mf NasmVM.jar NasmVM.class nasm
+
+C3aVM: C3aVM.java c3aParser
+	javac C3aVM.java
+
+NasmVM: NasmVM.java nasmParser
+	javac NasmVM.java
+
+Compiler.jar : Compiler
+	jar cmf Compiler.mf Compiler.jar *.class sc sa ts nasm util c3a fg ig lParser
+
+Compiler: Compiler.java lParser
+	javac Compiler.java
+
+lParser: l.cfg
+	java -jar ../sablecc/sablecc.jar l.cfg
+
+saParser: sa.cfg
+	java -jar ../sablecc/sablecc.jar sa.cfg
+
+c3aParser: c3a.cfg
+	java -jar ../sablecc/sablecc.jar c3a.cfg
+
+nasmParser: nasm.cfg
+	java -jar ../sablecc/sablecc.jar nasm.cfg
+
+ualParser: ual.cfg
+	java -jar ../sablecc/sablecc.jar ual.cfg
+
+clean:
+	-rm *.class
+	-rm sc/*.class
+	-rm sa/*.class
+	-rm c3a/*.class
+	-rm ts/*.class
+	-rm nasm/*.class
+	-rm fg/*.class
+	-rm ig/*.class
+	-rm util/intset/*.class
+	-rm util/graph/*.class
+	-rm util/*.class
+	-rm -r lParser
+	-rm -r saParser
+	-rm -r c3aParser
+	-rm -r nasmParser
+
diff --git a/src/NasmVM.java b/src/NasmVM.java
new file mode 100644
index 0000000000000000000000000000000000000000..28c41c611bdced47859ae5ccb6aee7a1630ff342
--- /dev/null
+++ b/src/NasmVM.java
@@ -0,0 +1,66 @@
+import ts.Ts;
+import ts.TsParser;
+import nasm.NasmEval;
+import nasm.Nasm;
+import nasm.LoadNasm;
+import java.io.IOException;
+
+
+public class NasmVM {
+    private int verboseLevel;
+    private int stackSize;
+    private Nasm code;
+    private String nasmFileName;
+
+    public NasmVM(String nasmFileName, int stackSize, int verboseLevel){
+	this.nasmFileName = nasmFileName;
+	this.stackSize = stackSize;
+	this.verboseLevel = verboseLevel;
+    }
+    
+    public void run() throws IOException {
+	LoadNasm loadNasm = new LoadNasm(nasmFileName);
+	this.code = loadNasm.getNasm();
+
+	if(verboseLevel > 0)
+       		code.afficheNasm(null);
+	
+        NasmEval eval = new NasmEval(code, stackSize, verboseLevel);
+	eval.displayOutput();
+    }
+
+    public static void main(String[] args){
+	int verboseLevel = 0;
+	int stackSize = 10000;
+	String nasmFileName = null;
+
+        try {
+	    for (int i = 0; i < args.length; i++) {
+		if(args[i].equals("-v"))
+		    verboseLevel = Integer.parseInt(args[++i]);
+		else if(args[i].equals("-s"))
+		    stackSize = Integer.parseInt(args[++i]);
+		else if(args[i].equals("-nasm"))
+		    nasmFileName = args[++i];
+	    }
+	    if(nasmFileName == null){
+		System.out.println("java NasmVM -nasm nasmFile -s stackSize -v verboseLevel");
+		System.exit(1);
+	    }
+	    var vm = new NasmVM(nasmFileName, stackSize, verboseLevel);
+	    vm.run();
+	}catch(IOException e){
+            e.printStackTrace();
+        }
+    }
+}
+
+/*
+        else{
+            var pathTab = preNasmFilePath.split("/");
+            var fileNamePreNasm = pathTab[pathTab.length - 1];
+            var fileName =  outputPath + fileNamePreNasm.substring(0, fileNamePreNasm.length()-3)+ ".out";
+            vm.displayOutput(fileName);
+        }
+    }
+*/
diff --git a/src/SaVM.java b/src/SaVM.java
new file mode 100644
index 0000000000000000000000000000000000000000..0588a6e4ac553f63b493023ac81fa096643e8dde
--- /dev/null
+++ b/src/SaVM.java
@@ -0,0 +1,46 @@
+import sa.*;
+import ts.*;
+
+public class SaVM {
+
+  public static void main(String[] args) {
+    int verboseLevel = 0;
+    String saFileName = null;
+
+    try {
+		for (int i = 0; i < args.length; i++) {
+			if(args[i].equals("-v"))
+				verboseLevel = Integer.parseInt(args[++i]);
+			else if(args[i].equals("-sa"))
+				saFileName = args[++i];
+		}
+		if(saFileName == null){
+			System.out.println("java SaVM -sa saFile -v verboseLevel");
+			System.exit(1);
+		}
+
+      if(verboseLevel > 0)
+		  System.err.println("parsing xml document");
+      if(verboseLevel > 0)
+		  System.err.println("building sa tree");
+      
+	  SaProg prog = new LoadSa(saFileName).getRoot();
+      if(verboseLevel > 0)
+		  System.out.println(prog);
+      
+      if(verboseLevel > 0)
+	  	System.err.println("building symbol table");
+	  	Sa2ts sa2ts = new Sa2ts();
+		prog.accept(sa2ts);
+		Ts tableGlobale = sa2ts.getTableGlobale();
+
+      if(verboseLevel > 0)
+		  System.err.println("evaluating sa tree");
+      SaEval saEval = new SaEval(prog, tableGlobale);
+      saEval.affiche(null);
+      
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}
diff --git a/src/c3a.cfg b/src/c3a.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..0737c8bfa0ab825607216415bdcd5941de62244f
--- /dev/null
+++ b/src/c3a.cfg
@@ -0,0 +1,113 @@
+Package c3aParser;
+
+Helpers
+
+lettre = [['a' .. 'z'] + ['A' .. 'Z']];
+chiffre = ['0' .. '9'];
+alpha = [lettre + ['_' + '$']];
+alphanum = [lettre + chiffre];
+
+Tokens
+
+espaces = (' ' | 13 | 10 | 9)+;
+commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13);
+
+
+co         = '[';
+cf         = ']';
+call       = 'call';
+stop       = 'stop';
+fbegin     = 'fbegin';
+fend       = 'fend';
+aff        = '=';
+noteq      = '!=';
+inf        = '<';
+infeq      = '<=';
+sup        = '>';
+supeq      = '>=';
+eq         = '==';
+goto       = 'goto';
+param      = 'param';
+ret        = 'ret';
+if         = 'if';
+moins      = '-';
+plus       = '+';
+fois       = '*';
+divise     = '/';
+write      = 'write';
+read       = 'read';
+nombre  = chiffre+;
+prefixe_temp = '@';
+identif    = alpha alphanum*;
+
+
+Ignored Tokens
+
+espaces, commentaire;
+
+Productions
+
+prog = listeinst;
+
+listeinst = {recursif} inst listeinst |
+        {final} inst
+	;
+
+inst = {add}      add |
+       {sub}      sub |
+       {mul}      mul |
+       {div}      div |
+       {aff}      affect |
+       {jmp}      jmp |
+       {jmpeg}    jmpeg |
+       {jmpneg}   jmpneg |
+       {jmpinf}   jmpinf |
+       {jminfeg}  jmpinfeg |
+       {jmpsup}   jmpsup |
+       {jmpsupeg} jmpsupeg |
+       {fcall}    fcall |
+       {iwrite}   iwrite |
+       {iread}    iread |
+       {arg}      arg |
+       {return}   return |
+       {begin}    begin |
+       {end}      end |
+       {stop}     istop
+       ;
+       
+add      = etiqop [result]:tv aff [op1]:ctv plus   [op2]:ctv; 
+sub      = etiqop [result]:tv aff [op1]:ctv moins  [op2]:ctv; 
+mul      = etiqop [result]:tv aff [op1]:ctv fois   [op2]:ctv; 
+div      = etiqop [result]:tv aff [op1]:ctv divise [op2]:ctv; 
+affect   = etiqop [result]:tv aff [op1]:ctv;
+jmpeg    = etiqop if [op1]:ctv eq   [op2]:ctv goto [result]:constante;
+jmpneg   = etiqop if [op1]:ctv noteq [op2]:ctv goto [result]:constante;
+jmpinf   = etiqop if [op1]:ctv inf   [op2]:ctv goto [result]:constante;
+jmpinfeg = etiqop if [op1]:ctv infeq [op2]:ctv goto [result]:constante;
+jmpsup   = etiqop if [op1]:ctv sup   [op2]:ctv goto [result]:constante;
+jmpsupeg = etiqop if [op1]:ctv supeq [op2]:ctv goto [result]:constante;
+jmp      = etiqop goto [result]:constante;
+begin    = identif fbegin;
+end      = etiqop fend;
+fcall    = etiqop [result]:tv aff call identif;
+iwrite   = etiqop write ctv;
+iread    = etiqop [result]:tv aff read;
+arg      = etiqop param ctv;
+return   = etiqop ret ctv;
+istop    = etiqop stop ctv;
+
+
+ctv = {c} constante | {t} temporaire | {v} variable;
+tv = {t} temporaire | {v} variable;
+
+constante = nombre;
+
+temporaire = prefixe_temp nombre;
+
+variable = {scalaire} identif |
+           {tab} identif co ctv cf
+           ;
+
+etiqop = {cte} nombre |
+         {vide}
+         ;
diff --git a/src/c3a/C3a.java b/src/c3a/C3a.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fe8ad58c8b423dc159a6e45c540be0709907942
--- /dev/null
+++ b/src/c3a/C3a.java
@@ -0,0 +1,87 @@
+package c3a;
+import java.util.*;
+import java.io.*;
+import ts.*;
+import sa.*;
+
+    
+public class C3a{
+    public List<C3aInst> listeInst;
+    // compteur des temporaires, pour générer des noms uniques
+    private int tempCounter;
+    // étiquette de la prochaine instruction, on retarde l'ajout de l'étiquette
+    private C3aLabel nextLabel;
+    private int labelCounter;
+    public C3aConstant True;
+    public C3aConstant False;
+
+    public C3a(){
+	this.listeInst = new ArrayList<C3aInst>();
+	this.labelCounter = 0;
+	this.tempCounter = 0;
+	this.nextLabel = null;
+	this.True = new C3aConstant(1); // constantes utilisées partout
+	this.False = new C3aConstant(0); // constantes utilisées partout
+    }
+
+	public int getTempCounter(){return this.tempCounter;}
+	public void setTempCounter(int value){this.tempCounter = value;}
+	public int getLabelCounter(){return this.labelCounter;}
+	public void setLableCounter(int value){this.labelCounter = value;}
+
+	public void ajouteInst(C3aInst inst){
+	if(this.nextLabel != null){
+	    inst.setLabel(this.nextLabel);
+	    this.nextLabel = null;
+	}
+	this.listeInst.add(inst);
+    }
+    
+    public C3aLabel newAutoLabel(){
+	return new C3aLabel(this.labelCounter++);
+    }
+
+    public C3aTemp newTemp(){
+	return new C3aTemp(this.tempCounter++);
+    }
+
+    public void addLabelToNextInst(C3aLabel label){
+	if(this.nextLabel != null){
+      label.affect(this.nextLabel);
+	    System.err.println("WARNING : Étiquette précédente ignorée " + this.nextLabel.getNumber());
+	}
+	this.nextLabel = label;
+	//	if(etiquette->oper_type == O_ETIQUETTE){
+	//   etiquette->u.oper_etiquette.ligne = c3a->next;
+	//}
+	//if(etiquette->oper_type == O_FCT){
+	//   etiquette->u.oper_fct->adresse = c3a->next;
+	//}
+    }
+
+    public void affiche(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".c3a";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+    	Iterator<C3aInst> iter = this.listeInst.iterator();
+    	while(iter.hasNext()){
+    	    out.println(iter.next());
+    	}
+    }
+	public <T> T accept(C3aVisitor <T> visitor) {
+		return visitor.visit(this);
+	}
+	
+}
+
diff --git a/src/c3a/C3aBooleanConstant.java b/src/c3a/C3aBooleanConstant.java
new file mode 100644
index 0000000000000000000000000000000000000000..419e5e9594910662e0a16ff356dd60ba0d3951b2
--- /dev/null
+++ b/src/c3a/C3aBooleanConstant.java
@@ -0,0 +1,15 @@
+package c3a;
+
+public class C3aBooleanConstant extends C3aOperand{
+    public boolean val;
+
+    public C3aBooleanConstant(boolean val){
+	this.val = val;
+    }
+
+    public String toString(){return String.valueOf(this.val);}
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aConstant.java b/src/c3a/C3aConstant.java
new file mode 100644
index 0000000000000000000000000000000000000000..657cdd3703253a2f0740666304c06c76f170720b
--- /dev/null
+++ b/src/c3a/C3aConstant.java
@@ -0,0 +1,15 @@
+package c3a;
+
+public class C3aConstant extends C3aOperand{
+    public int val;
+
+    public C3aConstant(int val){
+	this.val = val;
+    }
+
+    public String toString(){return Integer.toString(this.val);}
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aEval.java b/src/c3a/C3aEval.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1f2fd28fd1a611ce78cdb94d17202a07710edc8
--- /dev/null
+++ b/src/c3a/C3aEval.java
@@ -0,0 +1,385 @@
+package c3a;
+import java.util.*;
+import java.io.*;
+import ts.*;
+import util.Memory;
+import util.Type;
+
+public class C3aEval implements C3aVisitor <Integer> {
+    private C3a c3a;
+    private Ts tableGlobale;
+    private int nbReg;
+    private int[] reg;
+    private int[] stack;
+    private Memory varGlob;
+    private int eip;
+    private int ebp;
+    private int esp;
+    private int stackSize;
+    private Map< Integer, Integer> label2index;
+    private Map< String, Integer> function2index;
+    private boolean debug;
+    private boolean stop;
+    private ArrayList<String> programOutput = new ArrayList<String>();
+    private TsItemFct currentFct;
+    private Stack<TsItemFct> stackCurrentFct;
+    
+    private C3aOperand storeReturnValue;
+    private Stack<C3aOperand> stackStoreReturnValue;
+	private int verboseLevel;
+
+    
+    public C3aEval(C3a c3a, Ts tableGlobale, int stackSize, int verboseLevel){
+	debug = true;
+	this.verboseLevel = verboseLevel;
+	this.c3a = c3a;
+  	stack = new int[stackSize];
+	nbReg = c3a.getTempCounter();
+  	reg = new int[nbReg];
+  	esp = 0; 
+	varGlob = new Memory(tableGlobale.getAdrVarCourante(), 0);
+  	this.tableGlobale = tableGlobale;
+  	this.currentFct = null;
+  	storeReturnValue = null;
+  	label2index = new HashMap< Integer, Integer>();
+  	function2index = new HashMap< String, Integer>();
+  	C3aInst c3aInst = null;
+	stackCurrentFct = new Stack<>();
+	stackStoreReturnValue = new Stack<>();
+	eip = 0;
+	
+  	for(int i = 0; i < c3a.listeInst.size(); i++){
+  	    c3aInst = c3a.listeInst.get(i);
+  	    if(c3aInst.label != null){
+  		label2index.put(c3aInst.label.number, i);
+  	    }
+	    if(c3aInst instanceof C3aInstFBegin){
+		String identif = ((C3aInstFBegin)c3aInst).val.identif;
+		function2index.put(identif, i);
+	    }
+  	}
+
+  }
+
+  public C3a getC3a(){
+		return this.c3a;
+  }
+    public void afficheEtat(C3aInst inst){
+	System.out.println("---------------------------------------------");
+	System.out.println("eip = " + eip + "\tesp = " + esp + "\tebp = " + ebp);
+	System.out.print("PILE : ");
+	affichePile();
+	System.out.print("REGISTRES : ");
+	afficheReg();
+	System.out.println(inst);
+    }
+
+
+    
+    public void affiche(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+	
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".c3aout";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	for (String line : programOutput)
+	    out.println(line);
+    }
+    
+    
+    public void affichePileVertical(){
+	for(int i = esp-1; i >= 0; i--){
+	    System.out.println(i + ":" + stack[i]);
+	}
+    }
+
+    public void affichePile(){
+	for(int i = 0; i < esp; i++){
+	    System.out.print(stack[i] + " ");
+	}
+	    System.out.println("");
+	
+    }
+
+    public void push(int i){
+	if(esp == stackSize){
+	    System.out.println("stack overflow !!!");
+	    System.exit(1);
+	}
+	stack[esp] = i;
+	esp++;
+    }
+
+    public void afficheReg(){
+	for(int i=0; i <nbReg; i++)
+	    System.out.print(i + ":" + reg[i] + " ");
+	System.out.println("");
+    }
+    
+    public void pushReg(){
+	//	System.out.println("pushReg " + nbReg + " registers");
+	for(int i=0; i <nbReg; i++)
+	    push(reg[i]);
+    }
+    
+    public void popReg(){
+	//	System.out.println("popReg " + nbReg + " registers");
+	for(int i=nbReg-1; i >=0; i--)
+	    reg[i] = pop();
+    }
+    
+    public int pop(){
+	if(esp == 0){
+	    System.out.println("cannot pop empty stack !!!");
+	    System.exit(1);
+	}
+	esp--;
+	return stack[esp];
+    }
+
+	public Integer visit(C3a c3a){
+		stop = false;
+		C3aInst c3aInst;
+		while(!stop){
+			c3aInst = c3a.listeInst.get(eip);
+			//	    System.out.println("<" + c3aInst.getClass().getSimpleName() + ">");
+			if(verboseLevel > 0)
+				afficheEtat(c3aInst);
+
+			c3aInst.accept(this);
+		}
+		return 0;
+	}
+    public Integer visit(C3aConstant constant){
+	return constant.val;
+    }
+    
+    public Integer visit(C3aBooleanConstant constant){
+	return (constant.val == true)? 1 : 0;
+    }
+    
+    public Integer visit(C3aTemp temp){
+	return reg[temp.num];
+    }
+ 
+    public Integer visit(C3aVar var){
+	int adresse = var.item.adresse;
+	Type type =   var.item.type;
+	// variable globale
+	if(var.item.portee == this.tableGlobale){ 
+	    int offset = (var.index != null)? var.index.accept(this) : 0;
+	    //	    return varGlob[adresse/4 + offset];
+	    //	    System.out.println("adresse = " + adresse + " taille = " + type.taille());
+	    return varGlob.readNBytes(adresse + offset * type.taille(), type.taille());
+	}
+	if(var.item.isParam){ // parametre
+	    int nbArgs = this.currentFct.nbArgs;
+	    return stack[ebp - 2 - nbArgs + adresse / 4];
+	}
+	// variable locale
+	return stack[ebp + 1 + adresse / 4];
+    }
+
+    public void affect(C3aOperand op, int val){
+	if(op instanceof C3aVar){
+	    C3aVar var = (C3aVar) op;
+	    int adresse = var.item.adresse;
+	    int size = var.item.getType().taille();
+	    // variable globale
+	    if(var.item.portee == this.tableGlobale){ 
+		int offset = (var.index != null)? var.index.accept(this) : 0;
+		varGlob.writeInt(adresse + offset * size, val);
+	    }
+	    else if(var.item.isParam){ // parametre
+		int nbArgs = this.currentFct.nbArgs;
+		stack[ebp - 2 - nbArgs + adresse/4] = val;
+	    }
+	    else // variable locale
+		stack[ebp + 1 + adresse/4] = val;
+	}
+	else if(op instanceof C3aTemp){
+	    C3aTemp temp = (C3aTemp) op;
+	    reg[temp.num] = val;
+	}
+    }
+
+    public Integer visit(C3aFunction fct){
+	return null;
+    }
+
+    public Integer visit(C3aLabel label){
+	return label.number;
+    }
+    /*--------------------------------------------------------------------------------------------------------------*/
+    
+    public Integer visit(C3aInstStop inst){
+	stop = true;
+	return null;
+    }
+
+    public Integer visit(C3aInstAdd inst){
+	//if(debug){afficheEtat(inst);}
+	affect(inst.result, inst.op1.accept(this) + inst.op2.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstSub inst){
+	//if(debug){afficheEtat(inst);}
+	affect(inst.result, inst.op1.accept(this) - inst.op2.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstMult inst){
+	//if(debug){afficheEtat(inst);}
+	affect(inst.result, inst.op1.accept(this) * inst.op2.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstDiv inst){
+	//if(debug){afficheEtat(inst);}
+	affect(inst.result, inst.op1.accept(this) / inst.op2.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstJumpIfLess inst){
+	//if(debug){afficheEtat(inst);}
+	if(inst.op1.accept(this) < inst.op2.accept(this))
+	    eip = label2index.get(inst.result.accept(this));
+	else
+	    eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstJumpIfEqual inst){
+	//if(debug){afficheEtat(inst);}
+	if(inst.op1.accept(this) == inst.op2.accept(this))
+	    eip = label2index.get(inst.result.accept(this));
+	else
+	    eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstJumpIfNotEqual inst){
+	//if(debug){afficheEtat(inst);}
+	if(inst.op1.accept(this) != inst.op2.accept(this))
+	    eip = label2index.get(inst.result.accept(this));
+	else
+	    eip++;
+	return null;
+    }
+    
+    public Integer visit(C3aInstJump inst){
+	//if(debug){afficheEtat(inst);}
+	eip =  label2index.get(inst.result.accept(this));
+	return null;
+    }
+
+    public Integer visit(C3aInstAffect inst){
+	//if(debug){afficheEtat(inst);}
+	affect(inst.result, inst.op1.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstParam inst){
+	//if(debug){afficheEtat(inst);}
+	push(inst.op1.accept(this));
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstReturn inst){
+	//if(debug){afficheEtat(inst);}
+	stack[ebp - 2] = (inst.op1 != null)? inst.op1.accept(this) : 0;
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstWrite inst){
+	//if(debug){afficheEtat(inst);}
+	programOutput.add(inst.op1.accept(this).toString());
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstCall inst){
+	//if(debug){afficheEtat(inst);}
+	//	storeReturnValue = inst.result;
+	stackStoreReturnValue.push(inst.result);
+	// allocation mémoire pour la valeur de retour
+	//if(debug){System.out.println("allocation mémoire pour la valeur de retour, esp++");}
+	esp++;
+	//if(debug){System.out.println("sauvegarde de l'index de l'instruction à effectuer après l'appel : push(eip + 1)");}
+	push(eip + 1);
+	stackCurrentFct.push(currentFct);
+	eip = function2index.get(inst.op1.val.identif);
+	return null;
+   }
+
+    public Integer visit(C3aInstFBegin inst){
+	//if(debug){afficheEtat(inst);}
+	currentFct = inst.val;
+	int nbVarLoc = currentFct.getTable().getAdrVarCourante();
+	
+	//if(debug){System.out.println("sauvegarde de l'ancienne valeur de ebp");}
+	push(ebp);
+	//if(debug){System.out.println("nouvelle valeur de ebp");}
+	ebp = esp - 1;
+	//if(debug){System.out.println("allocation des variables locales");}
+	esp = esp + nbVarLoc;
+	pushReg();
+	eip++;
+	return null;
+    }
+
+    public Integer visit(C3aInstFEnd inst){
+	//if(debug){afficheEtat(inst);}
+	int nbVarLoc = currentFct.getTable().getAdrVarCourante();
+	int nbParam = currentFct.nbArgs;
+	popReg();
+	esp = esp - nbVarLoc;
+	ebp = pop();
+	eip = pop();
+	int rv = pop();
+	storeReturnValue = stackStoreReturnValue.pop();
+	if(storeReturnValue != null){
+	    affect(storeReturnValue, rv);
+	    storeReturnValue = null;
+	}
+	currentFct = stackCurrentFct.pop();
+	esp = esp - nbParam;
+	return null;
+    }
+
+    public Integer visit(C3aInstRead inst){
+	/*	Int label = (inst.label != null) ? inst.label.accept(this) : null;
+	Int result  = inst.result.accept(this);
+	NasmRegister reg_eax = nasm.newRegister();
+	reg_eax.colorRegister(Nasm.REG_EAX);
+
+	nasm.ajouteInst(new NasmMov (label, reg_eax, new NasmLabel("sinput"), "Read 1"));
+	nasm.ajouteInst(new NasmCall(null, new NasmLabel("readline"), "Read 2"));
+	nasm.ajouteInst(new NasmMov (null, reg_eax, new NasmLabel("sinput"), "Read 3"));
+	nasm.ajouteInst(new NasmMov (null, result, reg_eax , "Read 4"));*/
+	eip++;
+	return null;
+    }
+
+
+    public Integer visit(C3aInst inst){
+	return null;}
+    
+}
diff --git a/src/c3a/C3aFunction.java b/src/c3a/C3aFunction.java
new file mode 100644
index 0000000000000000000000000000000000000000..5966b6a4da41c95e7180e9843274d2c2e2a4d7f7
--- /dev/null
+++ b/src/c3a/C3aFunction.java
@@ -0,0 +1,20 @@
+package c3a;
+import ts.*;
+
+
+public class C3aFunction extends C3aOperand{
+    public TsItemFct val;
+
+    public C3aFunction(TsItemFct val){
+	this.val = val;
+    }
+
+    public TsItemFct getValue(){return val;}
+
+    public String toString(){
+	return this.val.getIdentif();
+    }
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aInst.java b/src/c3a/C3aInst.java
new file mode 100644
index 0000000000000000000000000000000000000000..9aafc68eb79a4d01da3670a2963dfcbcc0ea7410
--- /dev/null
+++ b/src/c3a/C3aInst.java
@@ -0,0 +1,16 @@
+package c3a;
+
+public class C3aInst{
+    public C3aLabel label ;   // étiquette optionnelle, si la ligne est cible d'un saut
+    public String comment;    // commentaire explicatif - utile pour le débogage
+
+    public void setLabel(C3aLabel label){
+	this.label = label;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstAdd.java b/src/c3a/C3aInstAdd.java
new file mode 100644
index 0000000000000000000000000000000000000000..49b9d92695eccf90a8915caaeef1da68ec25650f
--- /dev/null
+++ b/src/c3a/C3aInstAdd.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstAdd extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstAdd(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	if(this.label != null)
+	    return this.label + "\t" + this.result + " = " + this.op1 + " + " + this.op2 + this.comment;
+	else
+	    return              "\t" + this.result + " = " + this.op1 + " + " + this.op2 + this.comment;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstAffect.java b/src/c3a/C3aInstAffect.java
new file mode 100644
index 0000000000000000000000000000000000000000..8596b7bc4d6f12e8a9169144adf3a16c6ae19d58
--- /dev/null
+++ b/src/c3a/C3aInstAffect.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstAffect extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstAffect(C3aOperand op1, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null) s = s + this.label;
+	s = s + "\t";
+	s = s + this.result + " = " + this.op1 + this.comment;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+
+}
+
diff --git a/src/c3a/C3aInstCall.java b/src/c3a/C3aInstCall.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc5794fdba175ed546a679a280196cd5162c85aa
--- /dev/null
+++ b/src/c3a/C3aInstCall.java
@@ -0,0 +1,28 @@
+package c3a;
+
+public class C3aInstCall extends C3aInst{
+    public C3aFunction op1;    // opérande 1 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstCall(C3aFunction op1, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	if(this.result != null)
+	    s = s + this.result + " =";
+	s = s + " call " + this.op1 + this.comment;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstDiv.java b/src/c3a/C3aInstDiv.java
new file mode 100644
index 0000000000000000000000000000000000000000..77885d1feb97ec9dfd18b3464f87edaf5e765ca2
--- /dev/null
+++ b/src/c3a/C3aInstDiv.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstDiv extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstDiv(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	if(this.label != null)
+	    return this.label + "\t" + this.result + " = " + this.op1 + " / " + this.op2 + this.comment;
+	else
+	    return              "\t" + this.result + " = " + this.op1 + " / " + this.op2 + this.comment;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstFBegin.java b/src/c3a/C3aInstFBegin.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8a5f2c5a99cf8d248b70d7700a3b3ada08a38c5
--- /dev/null
+++ b/src/c3a/C3aInstFBegin.java
@@ -0,0 +1,23 @@
+package c3a;
+import ts.*;
+
+public class C3aInstFBegin extends C3aInst{
+    public TsItemFct val;
+    public C3aInstFBegin(TsItemFct val, String comment){
+	this.val = val;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	//	String s = "";
+	//	if(this.label != null)
+	//	    s = s + this.label;
+	return this.val.getIdentif() + "\tfbegin\t#" + this.comment;
+	//	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstFEnd.java b/src/c3a/C3aInstFEnd.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e0380f05ae0c72f9b234b8e10c0e2adf7d8676f
--- /dev/null
+++ b/src/c3a/C3aInstFEnd.java
@@ -0,0 +1,21 @@
+package c3a;
+
+public class C3aInstFEnd extends C3aInst{
+    public C3aInstFEnd(String comment){
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "fend";
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstJump.java b/src/c3a/C3aInstJump.java
new file mode 100644
index 0000000000000000000000000000000000000000..1324e5e43d8545aee99a9ccf0e769f2a7b0ca2ca
--- /dev/null
+++ b/src/c3a/C3aInstJump.java
@@ -0,0 +1,24 @@
+package c3a;
+
+public class C3aInstJump extends C3aInst{
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstJump(C3aOperand result, String comment){
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "goto " + this.result;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstJumpIfEqual.java b/src/c3a/C3aInstJumpIfEqual.java
new file mode 100644
index 0000000000000000000000000000000000000000..98bdb79305249c803e12a07c334ea4337d6958b7
--- /dev/null
+++ b/src/c3a/C3aInstJumpIfEqual.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstJumpIfEqual extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstJumpIfEqual(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\tif " + this.op1 + " == " + this.op2 + " goto " + this.result;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstJumpIfLess.java b/src/c3a/C3aInstJumpIfLess.java
new file mode 100644
index 0000000000000000000000000000000000000000..a88a20ecc8639fc2d64259e702ca8fe46dd7273b
--- /dev/null
+++ b/src/c3a/C3aInstJumpIfLess.java
@@ -0,0 +1,28 @@
+package c3a;
+
+public class C3aInstJumpIfLess extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstJumpIfLess(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "if " + this.op1 + " < " + this.op2 + " goto " + this.result;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstJumpIfNotEqual.java b/src/c3a/C3aInstJumpIfNotEqual.java
new file mode 100644
index 0000000000000000000000000000000000000000..06bc8c4a703a42789fa2f04b99acec26d4b320ac
--- /dev/null
+++ b/src/c3a/C3aInstJumpIfNotEqual.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstJumpIfNotEqual extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstJumpIfNotEqual(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\tif " + this.op1 + " != " + this.op2 + " goto " + this.result;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstMult.java b/src/c3a/C3aInstMult.java
new file mode 100644
index 0000000000000000000000000000000000000000..282d20a74c77185e289d4d4d216b113db48746b3
--- /dev/null
+++ b/src/c3a/C3aInstMult.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstMult extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstMult(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	if(this.label != null)
+	    return this.label + "\t" + this.result + " = " + this.op1 + " * " + this.op2 + this.comment;
+	else
+	    return              "\t" + this.result + " = " + this.op1 + " * " + this.op2 + this.comment;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstParam.java b/src/c3a/C3aInstParam.java
new file mode 100644
index 0000000000000000000000000000000000000000..44b96e2de53ed787d7338c9ad797ade474b232e3
--- /dev/null
+++ b/src/c3a/C3aInstParam.java
@@ -0,0 +1,25 @@
+package c3a;
+
+public class C3aInstParam extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+
+    public C3aInstParam(C3aOperand op1, String comment){
+	this.op1 = op1;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "param " + this.op1;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstRead.java b/src/c3a/C3aInstRead.java
new file mode 100644
index 0000000000000000000000000000000000000000..4586c03f89e52601f3e27cb00db075876ce4a091
--- /dev/null
+++ b/src/c3a/C3aInstRead.java
@@ -0,0 +1,25 @@
+package c3a;
+
+public class C3aInstRead extends C3aInst{
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstRead(C3aOperand result, String comment){
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + this.result + " = read #" + this.comment;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstReturn.java b/src/c3a/C3aInstReturn.java
new file mode 100644
index 0000000000000000000000000000000000000000..48d47a3ca66e6fe9b9505d371176645e6d73b9f3
--- /dev/null
+++ b/src/c3a/C3aInstReturn.java
@@ -0,0 +1,25 @@
+package c3a;
+
+public class C3aInstReturn extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+
+    public C3aInstReturn(C3aOperand op1, String comment){
+	this.op1 = op1;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "ret " + this.op1;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstStop.java b/src/c3a/C3aInstStop.java
new file mode 100644
index 0000000000000000000000000000000000000000..12404d552a20d9ee93e29dc4194de6a09d460703
--- /dev/null
+++ b/src/c3a/C3aInstStop.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstStop extends C3aInst{
+    public C3aOperand returnValue; 
+
+    public C3aInstStop(C3aOperand returnValue, String comment){
+	this.returnValue = returnValue;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "stop ";
+	if(this.returnValue != null)
+	    s = s + this.returnValue;
+	s = s + this.comment;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
+
diff --git a/src/c3a/C3aInstSub.java b/src/c3a/C3aInstSub.java
new file mode 100644
index 0000000000000000000000000000000000000000..18a985368f0c27d17add8712ca7ddd042b398c96
--- /dev/null
+++ b/src/c3a/C3aInstSub.java
@@ -0,0 +1,27 @@
+package c3a;
+
+public class C3aInstSub extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand op2;    // opérande 2 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstSub(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){
+	this.op1 = op1;
+	this.op2 = op2;
+	this.result = result;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	if(this.label != null)
+	    return this.label + "\t" + this.result + " = " + this.op1 + " - " + this.op2 + this.comment;
+	else
+	    return              "\t" + this.result + " = " + this.op1 + " - " + this.op2 + this.comment;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aInstWrite.java b/src/c3a/C3aInstWrite.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e1b1a7576b6e2dfe7a52c95950f0f366716d307
--- /dev/null
+++ b/src/c3a/C3aInstWrite.java
@@ -0,0 +1,26 @@
+package c3a;
+
+public class C3aInstWrite extends C3aInst{
+    public C3aOperand op1;    // opérande 1 (ou null)
+    public C3aOperand result; // résultat ou destination du saut (ou NULL)
+
+    public C3aInstWrite(C3aOperand op1, String comment){
+	this.op1 = op1;
+	this.comment = comment;
+    }
+
+    public String toString(){
+	String s = "";
+	if(this.label != null)
+	    s = s + this.label;
+	s = s + "\t";
+	s = s + "write " + this.op1 + "\t" + this.comment;
+	return s;
+    }
+
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
+
diff --git a/src/c3a/C3aLabel.java b/src/c3a/C3aLabel.java
new file mode 100644
index 0000000000000000000000000000000000000000..f70d1c3eca89af48274a5d9160811dec67d98997
--- /dev/null
+++ b/src/c3a/C3aLabel.java
@@ -0,0 +1,29 @@
+package c3a;
+
+public class C3aLabel extends C3aOperand{
+    public int number; // numéro de l'étiquette
+    private int line;   // ligne de l'opération correspondant à l'étiquette
+    //    public String name;
+    
+    //    public C3aLabel(int number, int line, String name){
+    public C3aLabel(int number){
+	this.number = number;
+	this.line = 0;
+	//	this.name = name;
+    }
+
+    public int getNumber(){return this.number;}
+    public int getLine(){return this.line;}
+
+    public String toString(){return String.valueOf(this.number);}
+//    public String toString(){return "l" + this.number;}
+
+    public void affect(C3aLabel other) {
+      this.number = other.number;
+      this.line = other.line;
+    }
+    
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aOp.java b/src/c3a/C3aOp.java
new file mode 100644
index 0000000000000000000000000000000000000000..e03daf69f03f5776343f30f55c6028bf5cc00cc8
--- /dev/null
+++ b/src/c3a/C3aOp.java
@@ -0,0 +1,24 @@
+package c3a;
+
+public enum C3aOp{
+	arithAdd,
+	arithSub,
+	arithMult,
+	arithDiv,
+	funcCall,
+	funcParam,
+	funcValRet,
+	funcBegin,
+	funcEnd,
+	assign,                                                    //affectation et transferts temporaires <-> variables
+	alloc, // allouer de la place pour variables
+	jump,
+	jump_if_less,
+	jump_if_less_or_equal,
+	jumpIfEqual,
+	jump_if_not_equal,
+	jump_if_greater,
+	jump_if_greater_or_equal,
+	sys_read,
+	sys_write; // lire et écrire (interruptions système)
+}
diff --git a/src/c3a/C3aOperand.java b/src/c3a/C3aOperand.java
new file mode 100644
index 0000000000000000000000000000000000000000..7744c0da123c4b51b25f59eef089c4f16bb27e1d
--- /dev/null
+++ b/src/c3a/C3aOperand.java
@@ -0,0 +1,7 @@
+package c3a;
+
+public abstract class C3aOperand {
+
+    public abstract <T> T accept(C3aVisitor <T> visitor);
+
+}
diff --git a/src/c3a/C3aTemp.java b/src/c3a/C3aTemp.java
new file mode 100644
index 0000000000000000000000000000000000000000..6958c45b43d7823215f39f77d5d2642e5acda957
--- /dev/null
+++ b/src/c3a/C3aTemp.java
@@ -0,0 +1,16 @@
+package c3a;
+
+public class C3aTemp extends C3aOperand{
+    public int num;
+
+    public C3aTemp(int num){
+	this.num = num;
+    }
+
+    public String toString(){
+	return "@" + this.num;
+    }
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aVar.java b/src/c3a/C3aVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..dcef2c2f3915df288eb0abe466574a1c27234d29
--- /dev/null
+++ b/src/c3a/C3aVar.java
@@ -0,0 +1,24 @@
+package c3a;
+import ts.*;
+
+public class C3aVar extends C3aOperand{
+    public TsItemVar item;
+    public C3aOperand index;
+
+    public C3aVar(TsItemVar item, C3aOperand index){
+	this.item = item;
+	this.index = index;
+    }
+
+    public String toString(){
+	if(this.index != null)
+	    //	    return this.item.getIdentif() + "[" + this.item.getTaille() + "]";
+	    return this.item.getIdentif() + "[" + this.index + "]";
+	else
+	    return this.item.getIdentif();
+    }
+    
+    public <T> T accept(C3aVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+}
diff --git a/src/c3a/C3aVisitor.java b/src/c3a/C3aVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8f2b96f99869605b801ddd21d33239ac703ae7d
--- /dev/null
+++ b/src/c3a/C3aVisitor.java
@@ -0,0 +1,30 @@
+package c3a;
+
+public interface C3aVisitor <T> {
+    public T visit(C3a c3a);
+    public T visit(C3aInstAdd inst);
+    public T visit(C3aInstCall inst);
+    public T visit(C3aInstFBegin inst);
+    public T visit(C3aInst inst);
+    public T visit(C3aInstJumpIfLess inst);
+    public T visit(C3aInstMult inst);
+    public T visit(C3aInstRead inst);
+    public T visit(C3aInstSub inst);
+    public T visit(C3aInstAffect inst);
+    public T visit(C3aInstDiv inst);
+    public T visit(C3aInstFEnd inst);
+    public T visit(C3aInstJumpIfEqual inst);
+    public T visit(C3aInstJumpIfNotEqual inst);
+    public T visit(C3aInstJump inst);
+    public T visit(C3aInstParam inst);
+    public T visit(C3aInstReturn inst);
+    public T visit(C3aInstWrite inst);
+    public T visit(C3aInstStop inst);
+
+    public T visit(C3aConstant oper);
+    public T visit(C3aBooleanConstant oper);
+    public T visit(C3aLabel oper);
+    public T visit(C3aTemp oper);
+    public T visit(C3aVar oper);
+    public T visit(C3aFunction oper);
+}
diff --git a/src/c3a/LoadC3a.java b/src/c3a/LoadC3a.java
new file mode 100644
index 0000000000000000000000000000000000000000..c321ea9b5c125cab957ab3f4e97e7cf0bedb99a5
--- /dev/null
+++ b/src/c3a/LoadC3a.java
@@ -0,0 +1,473 @@
+package c3a;
+import c3aParser.analysis.DepthFirstAdapter;
+import ts.*;
+import c3aParser.lexer.Lexer;
+import c3aParser.lexer.LexerException;
+import c3aParser.node.*;
+import c3aParser.parser.Parser;
+import c3aParser.parser.ParserException;
+import util.Error;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PushbackReader;
+
+public class LoadC3a extends DepthFirstAdapter {
+    private C3a c3a;
+    private C3aInst inst;
+    private C3aOperand operand;
+    private C3aLabel label;
+    private Ts tableGlobale;
+    private Ts tableLocale = null;
+
+    public LoadC3a(String c3aFileName, Ts tableGlobale) {
+        this.tableGlobale = tableGlobale;
+        PushbackReader fileReader = null;
+        Parser parser = null;
+        Start root = null;
+        try {
+            fileReader = new PushbackReader(new FileReader(c3aFileName));
+        } catch (IOException e) {
+            System.err.println("cannot open input file");
+            e.printStackTrace();
+        }
+        try {
+            parser = new Parser(new Lexer(fileReader));
+            root = parser.parse();
+        } catch (ParserException e) {
+            System.err.println("syntax error");
+            e.printStackTrace();
+            System.exit(Error.SYNT.code());
+        } catch (LexerException e) {
+            System.err.println("lexical error");
+            e.printStackTrace();
+            System.exit(Error.LEX.code());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        root.apply(this);
+    }
+
+    public void defaultIn(Node node)
+    {
+        //System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(Node node)
+    {
+        //System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+    public C3a getC3a(){return c3a;}
+    //prog = listeinst;
+    @Override
+    public void caseAProg(AProg node)
+    {
+        inAProg(node);
+        c3a = new C3a();
+        if(node.getListeinst() != null)
+        {
+            node.getListeinst().apply(this);
+        }
+        outAProg(node);
+    }
+//listeinst = {recursif} inst listeinst
+    @Override
+    public void caseARecursifListeinst(ARecursifListeinst node)
+    {
+        inARecursifListeinst(node);
+        node.getInst().apply(this);
+        c3a.ajouteInst(inst);
+        label = null;
+        node.getListeinst().apply(this);
+        outARecursifListeinst(node);
+    }
+
+//    listeinst = {final} inst
+    @Override
+    public void caseAFinalListeinst(AFinalListeinst node)
+    {
+        inAFinalListeinst(node);
+        node.getInst().apply(this);
+        c3a.ajouteInst(inst);
+        label = null;
+        outAFinalListeinst(node);
+    }
+
+    //add      = etiqop [result]:tv aff [op1]:ctv plus   [op2]:ctv;
+    @Override
+    public void caseAAdd(AAdd node)
+    {
+        inAAdd(node);
+        if(node.getEtiqop() != null)
+        {
+            node.getEtiqop().apply(this);
+            c3a.addLabelToNextInst(label);
+        }
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+        node.getOp1().apply(this);
+        C3aOperand op1 = operand;
+        node.getOp2().apply(this);
+        C3aOperand op2 = operand;
+        inst = new C3aInstAdd(op1, op2, result, "");
+        outAAdd(node);
+    }
+
+    //sub      = etiqop [result]:tv aff [op1]:ctv moins  [op2]:ctv;
+    @Override
+    public void caseASub(ASub node)
+    {
+        inASub(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        node.getOp1().apply(this);
+        C3aOperand op1 = operand;
+
+        node.getOp2().apply(this);
+        C3aOperand op2 = operand;
+
+        inst = new C3aInstSub(op1, op2, result, "");
+        outASub(node);
+    }
+
+    //mul      = etiqop [result]:tv aff [op1]:ctv fois   [op2]:ctv;
+    @Override
+    public void caseAMul(AMul node)
+    {
+        inAMul(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        node.getOp1().apply(this);
+        C3aOperand op1 = operand;
+
+        node.getOp2().apply(this);
+        C3aOperand op2 = operand;
+
+        inst = new C3aInstMult(op1,op2, result, "");
+        outAMul(node);
+    }
+
+    //div      = etiqop [result]:tv aff [op1]:ctv divise [op2]:ctv;
+    @Override
+    public void caseADiv(ADiv node)
+    {
+        inADiv(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        node.getOp1().apply(this);
+        C3aOperand op1 = operand;
+
+        node.getOp2().apply(this);
+        C3aOperand op2 = operand;
+
+        inst = new C3aInstDiv(op1,op2, result, "");
+        outADiv(node);
+    }
+
+
+    //istop    = etiqop stop ctv;
+    @Override
+    public void caseAIstop(AIstop node)
+    {
+        inAIstop(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getCtv().apply(this);
+        C3aOperand op1 = operand;
+
+        inst = new C3aInstStop(op1, "");
+        outAIstop(node);
+    }
+
+//    iwrite   = etiqop write ctv;
+
+    @Override
+    public void caseAIwrite(AIwrite node)
+    {
+        inAIwrite(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getCtv().apply(this);
+        C3aOperand op = operand;
+
+        inst = new C3aInstWrite(op, "");
+        outAIwrite(node);
+    }
+
+    // iread    = etiqop [result]:tv aff read;
+
+    @Override
+    public void caseAIread(AIread node)
+    {
+        inAIread(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        inst = new C3aInstRead(result, "");
+        outAIread(node);
+    }
+
+    //    end      = etiqop fend;
+@Override
+public void caseAEnd(AEnd node)
+{
+    inAEnd(node);
+    if(node.getEtiqop() != null)
+    {
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+    }
+    inst = new C3aInstFEnd("");
+    outAEnd(node);
+}
+
+//    affect   = etiqop [result]:tv aff [op1]:ctv;
+
+    @Override
+    public void caseAAffect(AAffect node)
+    {
+        inAAffect(node);
+        if(node.getEtiqop() != null)
+        {
+            node.getEtiqop().apply(this);
+            c3a.addLabelToNextInst(label);
+        }
+            node.getResult().apply(this);
+            C3aOperand result = operand;
+
+            node.getOp1().apply(this);
+            C3aOperand op1 = operand;
+            inst = new C3aInstAffect(op1, result, "");
+        outAAffect(node);
+    }
+
+//    jmpeg    = etiqop if [op1]:ctv aff  [op2]:ctv goto [result]:constante;
+@Override
+public void caseAJmpeg(AJmpeg node)
+{
+    inAJmpeg(node);
+    node.getEtiqop().apply(this);
+    c3a.addLabelToNextInst(label);
+
+    node.getOp1().apply(this);
+    C3aOperand op1 = operand;
+
+    node.getOp2().apply(this);
+    C3aOperand op2 = operand;
+
+    node.getResult().apply(this);
+    C3aOperand result = operand;
+
+    inst = new C3aInstJumpIfEqual(op1, op2, result, "");
+    outAJmpeg(node);
+}
+
+//    jmpinf   = etiqop if [op1]:ctv inf   [op2]:ctv goto [result]:constante;
+@Override
+public void caseAJmpinf(AJmpinf node)
+{
+    inAJmpinf(node);
+    node.getEtiqop().apply(this);
+    c3a.addLabelToNextInst(label);
+
+    node.getOp1().apply(this);
+    C3aOperand op1 = operand;
+
+    node.getOp2().apply(this);
+    C3aOperand op2 = operand;
+
+    node.getResult().apply(this);
+    C3aOperand result = operand;
+
+    inst = new C3aInstJumpIfLess(op1, op2, result, "");
+    outAJmpinf(node);
+}
+
+//    jmpneg = etiqop if [op1]:ctv noteg [op2]:ctv goto [result]:constante;
+@Override
+public void caseAJmpneg(AJmpneg node)
+{
+    inAJmpneg(node);
+    node.getEtiqop().apply(this);
+    c3a.addLabelToNextInst(label);
+
+    node.getOp1().apply(this);
+    C3aOperand op1 = operand;
+
+    node.getOp2().apply(this);
+    C3aOperand op2 = operand;
+
+    node.getResult().apply(this);
+    C3aOperand result = operand;
+
+    inst = new C3aInstJumpIfNotEqual(op1, op2, result, "");
+    outAJmpneg(node);
+}
+
+    @Override
+    public void caseAJmp(AJmp node)
+    {
+        inAJmp(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        inst = new C3aInstJump(result, "");
+        outAJmp(node);
+    }
+
+
+    //arg      = etiqop param ctv;
+    @Override
+    public void caseAArg(AArg node)
+    {
+        inAArg(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+
+        node.getCtv().apply(this);
+        C3aOperand op1 = operand;
+        inst = new C3aInstParam(op1, "");
+        outAArg(node);
+    }
+//return   = etiqop ret ctv;
+
+    @Override
+    public void caseAReturn(AReturn node)
+    {
+        inAReturn(node);
+        node.getEtiqop().apply(this);
+        c3a.addLabelToNextInst(label);
+        node.getCtv().apply(this);
+        C3aOperand op1 = operand;
+        inst = new C3aInstReturn(op1, "");
+        outAReturn(node);
+    }
+
+//temporaire = prefixe_temp constante;
+    @Override
+    public void caseATemporaire(ATemporaire node)
+    {
+        inATemporaire(node);
+        int num = Integer.parseInt(node.getNombre().getText());
+        if(num >= c3a.getTempCounter())
+            c3a.setTempCounter(num + 1);
+        operand = new C3aTemp(num);
+        outATemporaire(node);
+    }
+
+//constante = nombre;
+@Override
+public void caseAConstante(AConstante node) {
+    inAConstante(node);
+    int num = Integer.parseInt(node.getNombre().getText());
+    operand = new C3aConstant(num);
+    outAConstante(node);
+}
+
+@Override
+    public void caseAVideEtiqop(AVideEtiqop node)
+    {
+        inAVideEtiqop(node);
+        outAVideEtiqop(node);
+    }
+    //etiqop = {cte} constante;
+    @Override
+    public void caseACteEtiqop(ACteEtiqop node)
+    {
+        inACteEtiqop(node);
+        int num = Integer.parseInt(node.getNombre().getText());
+        this.label = new C3aLabel(num);
+        if (num >= c3a.getLabelCounter())
+            c3a.setLableCounter(num + 1);
+        outACteEtiqop(node);
+    }
+
+//    variable = {scalaire} identif
+    @Override
+    public void caseAScalaireVariable(AScalaireVariable node)
+    {
+        inAScalaireVariable(node);
+        String identif = node.getIdentif().getText();
+        TsItemVarSimple tsItemVarSimple = null;
+        if(tableLocale != null)
+            tsItemVarSimple = (TsItemVarSimple) tableLocale.getVar(identif);
+        if(tsItemVarSimple == null)
+            tsItemVarSimple = (TsItemVarSimple) tableGlobale.getVar(identif);
+        operand = new C3aVar(tsItemVarSimple, null);
+        outAScalaireVariable(node);
+    }
+
+//    variable = {tab} identif co ctv cf
+    @Override
+    public void caseATabVariable(ATabVariable node)
+    {
+        inATabVariable(node);
+        String identif = node.getIdentif().getText();
+        TsItemVarTab tsItemVarTab = null;
+        if(tableLocale != null)
+            tsItemVarTab = (TsItemVarTab) tableLocale.getVar(identif);
+        if(tsItemVarTab == null)
+            tsItemVarTab = (TsItemVarTab) tableGlobale.getVar(identif);
+        node.getCtv().apply(this);
+        C3aOperand index = operand;
+        operand = new C3aVar(tsItemVarTab, index);
+        outATabVariable(node);
+    }
+
+
+    @Override
+    public void caseABegin(ABegin node)
+    {
+        inABegin(node);
+
+        String functionName = node.getIdentif().getText();
+        TsItemFct tsItemFct = tableGlobale.getFct(functionName);
+        tableLocale = tsItemFct.getTable();
+        inst = new C3aInstFBegin(tsItemFct, "");
+        outABegin(node);
+    }
+
+    //fcall    = etiqop [result]:tv aff call identif;
+    @Override
+    public void caseAFcall(AFcall node)
+    {
+        inAFcall(node);
+        if(node.getEtiqop() != null)
+        {
+            node.getEtiqop().apply(this);
+        }
+        node.getResult().apply(this);
+        C3aOperand result = operand;
+
+        C3aFunction op1 = new C3aFunction(tableGlobale.getFct(node.getIdentif().getText()));
+        inst = new C3aInstCall(op1, result, "");
+
+        outAFcall(node);
+    }
+
+
+}
+
+
+
diff --git a/src/c3a/Sa2c3a.java b/src/c3a/Sa2c3a.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e1a01f8920f5c383c6ec223d7a1bdfb1df11b55
--- /dev/null
+++ b/src/c3a/Sa2c3a.java
@@ -0,0 +1,49 @@
+package c3a;
+import ts.*;
+import sa.*;
+
+
+public class Sa2c3a extends SaDepthFirstVisitor <C3aOperand> {
+    private C3a c3a;
+    int indentation;
+    public C3a getC3a(){return this.c3a;}
+    
+    public Sa2c3a(SaNode root, Ts tableGlobale){
+	c3a = new C3a();
+	C3aTemp result = c3a.newTemp();
+	C3aFunction fct = new C3aFunction(tableGlobale.getFct("main"));
+	c3a.ajouteInst(new C3aInstCall(fct, result, ""));
+	c3a.ajouteInst(new C3aInstStop(result, ""));
+	indentation = 0;
+    }
+
+    public void defaultIn(SaNode node)
+    {
+	//for(int i = 0; i < indentation; i++){System.out.print(" ");}
+	//indentation++;
+	//System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(SaNode node)
+    {
+	//indentation--;
+	//	for(int i = 0; i < indentation; i++){System.out.print(" ");}
+	//	System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+    
+
+    // EXP -> op2 EXP EXP
+    public C3aOperand visit(SaExpAdd node) throws Exception
+    {
+	defaultIn(node);
+	C3aOperand op1 = node.getOp1().accept(this);
+	C3aOperand op2 = node.getOp2().accept(this);
+	C3aOperand result = c3a.newTemp();
+
+	c3a.ajouteInst(new C3aInstAdd(op1, op2, result, ""));
+	defaultOut(node);
+	return result;
+    }
+
+
+}
diff --git a/src/fg/Fg.java b/src/fg/Fg.java
new file mode 100644
index 0000000000000000000000000000000000000000..c306fd59e2633583fd7a07b50244db85c790c57b
--- /dev/null
+++ b/src/fg/Fg.java
@@ -0,0 +1,87 @@
+package fg;
+import nasm.*;
+import util.graph.*;
+import java.util.*;
+import java.io.*;
+
+public class Fg implements NasmVisitor <Void> {
+    public Nasm nasm;
+    public Graph graph;
+    Map< NasmInst, Node> inst2Node;
+    Map< Node, NasmInst> node2Inst;
+    Map< String, NasmInst> label2Inst;
+
+    public Fg(Nasm nasm){
+	this.nasm = nasm;
+	this.inst2Node = new HashMap< NasmInst, Node>();
+	this.node2Inst = new HashMap< Node, NasmInst>();
+	this.label2Inst = new HashMap< String, NasmInst>();
+	this.graph = new Graph();
+    }
+
+    public void affiche(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+	
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".fg";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	
+	for(NasmInst nasmInst : nasm.sectionText){
+	    Node n = this.inst2Node.get(nasmInst);
+	    out.print(n + " : ( ");
+	    for(NodeList q=n.succ(); q!=null; q=q.tail) {
+		out.print(q.head.toString());
+		out.print(" ");
+	    }
+	    out.println(")\t" + nasmInst);
+	}
+	
+    }
+
+    public Void visit(NasmAdd inst){return null;}
+    public Void visit(NasmCall inst){return null;}
+    public Void visit(NasmDiv inst){return null;}
+    public Void visit(NasmJe inst){return null;}
+    public Void visit(NasmJle inst){return null;}
+    public Void visit(NasmJne inst){return null;}
+    public Void visit(NasmMul inst){return null;}
+    public Void visit(NasmOr inst){return null;}
+    public Void visit(NasmCmp inst){return null;}
+    public Void visit(NasmInst inst){return null;}
+    public Void visit(NasmJge inst){return null;}
+    public Void visit(NasmJl inst){return null;}
+    public Void visit(NasmNot inst){return null;}
+    public Void visit(NasmPop inst){return null;}
+    public Void visit(NasmRet inst){return null;}
+    public Void visit(NasmXor inst){return null;}
+    public Void visit(NasmAnd inst){return null;}
+    public Void visit(NasmJg inst){return null;}
+    public Void visit(NasmJmp inst){return null;}
+    public Void visit(NasmMov inst){return null;}
+    public Void visit(NasmPush inst){return null;}
+    public Void visit(NasmSub inst){return null;}
+    public Void visit(NasmEmpty inst){return null;}
+    public Void visit(NasmInt inst){return null;}
+    public Void visit(NasmAddress operand){return null;}
+    public Void visit(NasmConstant operand){return null;}
+    public Void visit(NasmLabel operand){return null;}
+    public Void visit(NasmRegister operand){return null;}
+    public Void visit(NasmResb pseudoInst){return null;}
+    public Void visit(NasmResw pseudoInst){return null;}
+    public Void visit(NasmResd pseudoInst){return null;}
+    public Void visit(NasmResq pseudoInst){return null;}
+    public Void visit(NasmRest pseudoInst){return null;}
+    public Void visit(NasmExpPlus exp){return null;}
+    public Void visit(NasmExpMinus exp){return null;}
+    public Void visit(NasmExpTimes exp){return null;}
+    public Void visit(NasmExp exp){return null;}
+}
diff --git a/src/fg/FgSolution.java b/src/fg/FgSolution.java
new file mode 100644
index 0000000000000000000000000000000000000000..0970759509bbf4365786cb26710f8aecbd3766b0
--- /dev/null
+++ b/src/fg/FgSolution.java
@@ -0,0 +1,51 @@
+package fg;
+import util.graph.*;
+import nasm.*;
+import util.intset.*;
+import java.io.*;
+import java.util.*;
+
+public class FgSolution{
+    int iterNum = 0;
+    public Nasm nasm;
+    Fg fg;
+    public Map< NasmInst, IntSet> use;
+    public Map< NasmInst, IntSet> def;
+    public Map< NasmInst, IntSet> in;
+    public Map< NasmInst, IntSet> out;
+    
+    public FgSolution(Nasm nasm, Fg fg){
+	this.nasm = nasm;
+	this.fg = fg;
+	this.use = new HashMap< NasmInst, IntSet>();
+	this.def = new HashMap< NasmInst, IntSet>();
+	this.in =  new HashMap< NasmInst, IntSet>();
+	this.out = new HashMap< NasmInst, IntSet>();
+    }
+    
+    public void affiche(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".fgs";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	
+	out.println("iter num = " + iterNum);
+	for(NasmInst nasmInst : this.nasm.sectionText){
+	    out.println("use = "+ this.use.get(nasmInst) + " def = "+ this.def.get(nasmInst) + "\tin = " + this.in.get(nasmInst) + "\t \tout = " + this.out.get(nasmInst) + "\t \t" + nasmInst);
+	}
+	
+    }
+
+
+
+}
diff --git a/src/ig/Ig.java b/src/ig/Ig.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaf4886ff148177147648092d82af66a28a03af4
--- /dev/null
+++ b/src/ig/Ig.java
@@ -0,0 +1,61 @@
+package ig;
+
+import fg.*;
+import nasm.*;
+import util.graph.*;
+import util.intset.*;
+import java.util.*;
+import java.io.*;
+
+public class Ig {
+    public Graph graph;
+    public FgSolution fgs;
+    public int regNb;
+    public Nasm nasm;
+    public Node int2Node[];
+    
+    
+    public Ig(FgSolution fgs){
+	this.fgs = fgs;
+ 	this.graph = new Graph();
+	this.nasm = fgs.nasm;
+	this.regNb = this.nasm.getTempCounter();
+	this.int2Node = new Node[regNb];
+	this.build();
+    }
+    
+    public void build(){
+    }
+
+    public void affiche(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+	
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".ig";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	
+	for(int i = 0; i < regNb; i++){
+	    Node n = this.int2Node[i];
+	    out.print(n + " : ( ");
+	    for(NodeList q=n.succ(); q!=null; q=q.tail) {
+		out.print(q.head.toString());
+		out.print(" ");
+	    }
+	    out.println(")");
+	}
+    }
+}
+	    
+    
+
+    
+    
diff --git a/src/l.cfg b/src/l.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..5159f484cf0ea7172ce62b4aad5a0aaf3ab18347
--- /dev/null
+++ b/src/l.cfg
@@ -0,0 +1,32 @@
+Package lParser;
+
+Helpers
+
+lettre = [['a' .. 'z'] + ['A' .. 'Z']];
+chiffre = ['0' .. '9'];
+alpha = [lettre + ['_' + '$']];
+alphanum = [lettre + chiffre];
+
+Tokens
+
+espaces = (' ' | 13 | 10)+;
+commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13);
+plus = '+';
+nombre = chiffre+;
+
+
+Ignored Tokens
+
+espaces, commentaire;
+
+Productions
+
+// l'axiome
+
+programme = exp ;
+
+exp =
+     {plus} exp plus nombre |
+     {nb} nombre ;
+
+
diff --git a/src/nasm.cfg b/src/nasm.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cbc3812ff198b459a7b8ef13cd583983504283d9
--- /dev/null
+++ b/src/nasm.cfg
@@ -0,0 +1,210 @@
+Package nasmParser;
+
+Helpers
+
+letter = [['a' .. 'z'] + ['A' .. 'Z']];
+digit = ['0' .. '9'];
+alpha = [letter + ['_' + '$']];
+alphanum = [letter + digit];
+
+Tokens
+
+spaces = (' ' | 13 | 10 | 9)+;
+comment= ';' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13);
+
+plus       = '+';
+minus      = '-';
+times      = '*';
+brackopen  = '[';
+brackclose = ']';
+semicol    = ':';
+comma      = ',';
+quote      = ''';
+dot        = '.';
+percentage = '%';
+byte       = 'byte';
+word       = 'word';
+dword      = 'dword';
+prefix_register = '@';
+
+inc = 'include';
+section = 'section';
+
+data =             '.data';
+definebyte =       'db';
+defineword =       'dw';
+definedoubleword = 'dd';
+definequadword =   'dq';
+definetenbytes =   'dt';
+
+bss =               '.bss';
+reservebyte =       'resb';
+reserveword =       'resw';
+reservedoubleword = 'resd';
+reservequadword =   'resq';
+reservetenbytes =   'rest';
+
+text = '.text';
+
+global = 'global';
+
+mov =  'mov';
+push = 'push';
+pop =  'pop';
+add =  'add';
+sub =  'sub';
+imul = 'imul';
+idiv = 'idiv';
+and =  'and';
+or =   'or';
+xor =  'xor';
+not =  'not';
+cmp =  'cmp';
+jmp =  'jmp';
+je =   'je';
+jne =  'jne';
+jg =   'jg';
+jge =  'jge';
+jl =   'jl';
+jle =  'jle';
+call = 'call';
+ret =   'ret';
+int =	'int 0x80';
+
+eax =  'eax';
+ebx =  'ebx';
+ecx =  'ecx';
+edx =  'edx';
+ebp =  'ebp';
+esp =  'esp';
+
+number  = digit+;
+
+id    = alpha alphanum*;
+
+Ignored Tokens
+
+spaces, comment;
+
+Productions
+
+prog = linclude secdata secbss sectext;
+
+linclude = {rec} include linclude 
+         | {empty};
+
+include = percentage inc [open]: quote filename [close]: quote ;
+
+filename =   {simple} label 
+           | {complex} [prefix]: label dot [suffix]: label
+           ;
+
+secdata =   {nonempty} section data lconst
+          | {empty}
+	  ;
+
+lconst =   {rec} const lconst
+         | {empty} ;
+
+const =        {db} label definebyte numconst
+             | {dw} label defineword numconst
+             | {dd} label definedoubleword numconst
+             | {dq} label definequadword numconst
+             | {dt} label definetenbytes numconst
+             ;
+
+secbss =   {nonempty} section bss lvar
+         | {empty}
+	 ;
+
+lvar =   {rec} var lvar
+       | {empty}
+       ;
+
+var =          {resb} label semicol reservebyte number
+             | {resw} label semicol reserveword number
+             | {resd} label semicol reservedoubleword number
+             | {resq} label semicol reservequadword number
+             | {rest} label semicol reservetenbytes number
+             ;
+
+sectext = section text lglobal linst;
+
+lglobal = {rec} global label lglobal
+        | {empty}
+        ;
+
+linst = {rec} inst linst |
+        {last} inst
+	;
+
+inst =   {mov}    oplabel mov  ar comma acr
+       | {push}   oplabel push acr
+       | {pop}    oplabel pop  ar
+       | {add}    oplabel add  ar comma acr
+       | {sub}    oplabel sub  ar comma acr
+       | {imul}   oplabel imul ar comma acr
+       | {idiv}   oplabel idiv ar
+       | {and}    oplabel and  ar comma acr
+       | {or}     oplabel or   ar comma acr
+       | {xor}    oplabel xor  ar comma acr
+       | {not}    oplabel not  ar
+       | {cmp}    oplabel cmp  ar comma acr
+       | {jmp}    oplabel jmp  label
+       | {je}     oplabel je   label
+       | {jne}    oplabel jne  label
+       | {jg}     oplabel jg   label
+       | {jge}    oplabel jge  label
+       | {jl}     oplabel jl   label
+       | {call}   oplabel call label
+       | {ret}    oplabel ret
+       | {inter}  oplabel int
+       ;
+
+acr = {address} address
+    | {numconst} numconst
+    | {register} register
+    ;
+
+ar = {address} address
+   | {register} register
+   ;
+
+address = opsizeof brackopen exp brackclose;
+
+opsizeof = {byte} byte
+	 | {word} word
+	 | {dword} dword
+	 | {empty}
+	 ; 
+
+exp = {plus}  exp plus exp1
+    | {minus} exp minus exp1
+    | {next}  exp1
+    ;
+
+exp1 = {times} exp1 times exp2
+     | {next}  exp2
+     ;
+
+exp2 = {label} label
+     | {numconst} numconst
+     | {register} register
+     ;
+
+numconst = number;
+
+register = {temp} prefix_register number 
+         | {eax} eax
+	 | {ebx} ebx
+	 | {ecx} ecx
+	 | {edx} edx
+	 | {ebp} ebp
+	 | {esp} esp
+	 ;
+
+oplabel = {label} label semicol
+        | {empty}
+        ;
+
+label = id;
diff --git a/src/nasm/C3a2nasm.java b/src/nasm/C3a2nasm.java
new file mode 100644
index 0000000000000000000000000000000000000000..de33f5cf53abc9f77d42922fa678d27e59974e96
--- /dev/null
+++ b/src/nasm/C3a2nasm.java
@@ -0,0 +1,59 @@
+package nasm;
+import java.util.*;
+import ts.*;
+import c3a.*;
+
+public class C3a2nasm implements C3aVisitor <NasmOperand> {
+    private C3a c3a;
+    private Nasm nasm;
+    private Ts tableGlobale;
+    private TsItemFct currentFct;
+    private NasmRegister esp;
+    private NasmRegister ebp;
+
+    
+    public C3a2nasm(C3a c3a, Ts tableGlobale){
+		this.c3a = c3a;
+		nasm = new Nasm(tableGlobale);
+		nasm.setTempCounter(c3a.getTempCounter());
+
+		this.tableGlobale = tableGlobale;
+		this.currentFct = null;
+		esp = new NasmRegister(-1);
+		esp.colorRegister(Nasm.REG_ESP);
+
+		ebp = new NasmRegister(-1);
+		ebp.colorRegister(Nasm.REG_EBP);
+    }
+
+    public Nasm getNasm(){return nasm;}
+
+
+    public NasmOperand visit(C3a c3a){return null;}
+    public NasmOperand visit(C3aInstAdd inst){return null;}
+    public NasmOperand visit(C3aInstCall inst){return null;}
+    public NasmOperand visit(C3aInstFBegin inst){return null;}
+    public NasmOperand visit(C3aInst inst){return null;}
+    public NasmOperand visit(C3aInstJumpIfLess inst){return null;}
+    public NasmOperand visit(C3aInstMult inst){return null;}
+    public NasmOperand visit(C3aInstRead inst){return null;}
+    public NasmOperand visit(C3aInstSub inst){return null;}
+    public NasmOperand visit(C3aInstAffect inst){return null;}
+    public NasmOperand visit(C3aInstDiv inst){return null;}
+    public NasmOperand visit(C3aInstFEnd inst){return null;}
+    public NasmOperand visit(C3aInstJumpIfEqual inst){return null;}
+    public NasmOperand visit(C3aInstJumpIfNotEqual inst){return null;}
+    public NasmOperand visit(C3aInstJump inst){return null;}
+    public NasmOperand visit(C3aInstParam inst){return null;}
+    public NasmOperand visit(C3aInstReturn inst){return null;}
+    public NasmOperand visit(C3aInstWrite inst){return null;}
+    public NasmOperand visit(C3aInstStop inst){return null;}
+
+    public NasmOperand visit(C3aConstant oper){return null;}
+    public NasmOperand visit(C3aBooleanConstant oper){return null;}
+    public NasmOperand visit(C3aLabel oper){return null;}
+    public NasmOperand visit(C3aTemp oper){return null;}
+    public NasmOperand visit(C3aVar oper){return null;}
+    public NasmOperand visit(C3aFunction oper){return null;}
+    
+}
diff --git a/src/nasm/LoadNasm.java b/src/nasm/LoadNasm.java
new file mode 100644
index 0000000000000000000000000000000000000000..e68802c4e5f0b303877c33d8fc67a565c183b92a
--- /dev/null
+++ b/src/nasm/LoadNasm.java
@@ -0,0 +1,1117 @@
+package nasm;
+import nasmParser.analysis.DepthFirstAdapter;
+import nasmParser.lexer.Lexer;
+import nasmParser.lexer.LexerException;
+import nasmParser.node.*;
+import nasmParser.parser.Parser;
+import nasmParser.parser.ParserException;
+//import sc.analysis.DepthFirstAdapter;
+import util.Error;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PushbackReader;
+
+public class LoadNasm extends DepthFirstAdapter {
+    private Nasm nasm;
+    private NasmInst inst;
+    private NasmPseudoInst pseudoInst;
+    private NasmOperand operand;
+    private NasmLabel label;
+    private NasmExp exp;
+    private NasmSize size;
+    public LoadNasm(String nasmFileName) {
+        nasm = new Nasm();
+        PushbackReader fileReader = null;
+        Parser parser = null;
+        Start root = null;
+        try {
+            fileReader = new PushbackReader(new FileReader(nasmFileName));
+        } catch (IOException e) {
+            System.err.println("cannot open input file");
+            e.printStackTrace();
+        }
+        try {
+            parser = new Parser(new Lexer(fileReader));
+            root = parser.parse();
+        } catch (ParserException e) {
+            System.err.println("syntax error");
+            e.printStackTrace();
+            System.exit(Error.SYNT.code());
+        } catch (LexerException e) {
+            System.err.println("lexical error");
+            e.printStackTrace();
+            System.exit(Error.LEX.code());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        root.apply(this);
+    }
+
+    public void defaultIn(Node node)
+    {
+	//        System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(Node node)
+    {
+	//        System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+    public Nasm getNasm(){return nasm;}
+
+
+    // prog = linclude secdata secbss sectext
+    @Override
+    public void caseAProg(AProg node)
+    {
+        inAProg(node);
+        if(node.getLinclude() != null)
+        {
+            node.getLinclude().apply(this);
+        }
+        if(node.getSecdata() != null)
+        {
+            node.getSecdata().apply(this);
+        }
+        if(node.getSecbss() != null)
+        {
+            node.getSecbss().apply(this);
+        }
+        if(node.getSectext() != null)
+        {
+            node.getSectext().apply(this);
+        }
+        outAProg(node);
+    }
+
+    // linclude = {rec} include linclude 
+    @Override
+    public void caseARecLinclude(ARecLinclude node)
+    {
+        inARecLinclude(node);
+        if(node.getInclude() != null)
+        {
+            node.getInclude().apply(this);
+        }
+        if(node.getLinclude() != null)
+        {
+            node.getLinclude().apply(this);
+        }
+        outARecLinclude(node);
+    }
+
+    // linclude = {empty}
+    @Override
+    public void caseAEmptyLinclude(AEmptyLinclude node)
+    {
+        inAEmptyLinclude(node);
+        outAEmptyLinclude(node);
+    }
+    
+    // include = percentage inc [open]: quote filename [close]: quote 
+    @Override
+    public void caseAInclude(AInclude node)
+    {
+        inAInclude(node);
+        if(node.getPercentage() != null)
+        {
+            node.getPercentage().apply(this);
+        }
+        if(node.getInc() != null)
+        {
+            node.getInc().apply(this);
+        }
+        if(node.getOpen() != null)
+        {
+            node.getOpen().apply(this);
+        }
+        if(node.getFilename() != null)
+        {
+            node.getFilename().apply(this);
+        }
+        if(node.getClose() != null)
+        {
+            node.getClose().apply(this);
+        }
+        outAInclude(node);
+    }
+
+    // filename =  {simple} label 
+    @Override
+    public void caseASimpleFilename(ASimpleFilename node)
+    {
+        inASimpleFilename(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        outASimpleFilename(node);
+    }
+
+    // filename =  {complex} [prefix]: label dot [suffix]: label
+    @Override
+    public void caseAComplexFilename(AComplexFilename node)
+    {
+        inAComplexFilename(node);
+        if(node.getPrefix() != null)
+        {
+            node.getPrefix().apply(this);
+        }
+        if(node.getDot() != null)
+        {
+            node.getDot().apply(this);
+        }
+        if(node.getSuffix() != null)
+        {
+            node.getSuffix().apply(this);
+        }
+        outAComplexFilename(node);
+    }
+
+    // secdata =   {nonempty} section data lconst
+    @Override
+    public void caseANonemptySecdata(ANonemptySecdata node)
+    {
+        inANonemptySecdata(node);
+        if(node.getSection() != null)
+        {
+            node.getSection().apply(this);
+        }
+        if(node.getData() != null)
+        {
+            node.getData().apply(this);
+        }
+        if(node.getLconst() != null)
+        {
+            node.getLconst().apply(this);
+        }
+        outANonemptySecdata(node);
+    }
+
+    // secdata =   {empty}
+    @Override
+    public void caseAEmptySecdata(AEmptySecdata node)
+    {
+        inAEmptySecdata(node);
+        outAEmptySecdata(node);
+    }
+
+    // lconst =   {rec} const lconst
+    @Override
+    public void caseARecLconst(ARecLconst node)
+    {
+        inARecLconst(node);
+        if(node.getConst() != null)
+        {
+            node.getConst().apply(this);
+        }
+        if(node.getLconst() != null)
+        {
+            node.getLconst().apply(this);
+        }
+        outARecLconst(node);
+    }
+
+
+    // lconst =   {empty} 
+    @Override
+    public void caseAEmptyLconst(AEmptyLconst node)
+    {
+        inAEmptyLconst(node);
+        outAEmptyLconst(node);
+    }
+
+    // const = {db} label definebyte numconst
+    @Override
+    public void caseADbConst(ADbConst node)
+    {
+        inADbConst(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getDefinebyte() != null)
+        {
+            node.getDefinebyte().apply(this);
+        }
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outADbConst(node);
+    }
+
+    // const = {dw} label defineword numconst
+    @Override
+    public void caseADwConst(ADwConst node)
+    {
+        inADwConst(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getDefineword() != null)
+        {
+            node.getDefineword().apply(this);
+        }
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outADwConst(node);
+    }
+
+    // const = {dd} label definedoubleword numconst
+    @Override
+    public void caseADdConst(ADdConst node)
+    {
+        inADdConst(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getDefinedoubleword() != null)
+        {
+            node.getDefinedoubleword().apply(this);
+        }
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outADdConst(node);
+    }
+    // const = {dq} label definequadword numconst
+    @Override
+    public void caseADqConst(ADqConst node)
+    {
+        inADqConst(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getDefinequadword() != null)
+        {
+            node.getDefinequadword().apply(this);
+        }
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outADqConst(node);
+    }
+    // const = {dt} label definetenbytes numconst
+    @Override
+    public void caseADtConst(ADtConst node)
+    {
+        inADtConst(node);
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getDefinetenbytes() != null)
+        {
+            node.getDefinetenbytes().apply(this);
+        }
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outADtConst(node);
+    }
+
+
+    // secbss =   {nonempty} section bss lvar
+    @Override
+    public void caseANonemptySecbss(ANonemptySecbss node)
+    {
+        inANonemptySecbss(node);
+        if(node.getSection() != null)
+        {
+            node.getSection().apply(this);
+        }
+        if(node.getBss() != null)
+        {
+            node.getBss().apply(this);
+        }
+        if(node.getLvar() != null)
+        {
+            node.getLvar().apply(this);
+        }
+        outANonemptySecbss(node);
+    }
+    // secbss =   {empty}
+    @Override
+    public void caseAEmptySecbss(AEmptySecbss node)
+    {
+        inAEmptySecbss(node);
+        outAEmptySecbss(node);
+    }
+
+    // lvar =   {rec} var lvar
+    @Override
+    public void caseARecLvar(ARecLvar node)
+    {
+        inARecLvar(node);
+        node.getVar().apply(this);
+        nasm.ajoutePseudoInst(pseudoInst);
+        node.getLvar().apply(this);
+        outARecLvar(node);
+    }
+    // lvar =   {empty}
+    @Override
+    public void caseAEmptyLvar(AEmptyLvar node)
+    {
+        inAEmptyLvar(node);
+        outAEmptyLvar(node);
+    }
+
+    // var = {resb} label reservebyte number
+    @Override
+    public void caseAResbVar(AResbVar node)
+    {
+        inAResbVar(node);
+        node.getLabel().apply(this);
+
+        int nb = Integer.parseInt(node.getNumber().getText());
+        pseudoInst = new NasmResb(label,nb,"");
+        outAResbVar(node);
+    }
+    // var = {resw} label reserveword number
+    @Override
+    public void caseAReswVar(AReswVar node)
+    {
+        inAReswVar(node);
+        node.getLabel().apply(this);
+        int nb = Integer.parseInt(node.getNumber().getText());
+        pseudoInst = new NasmResw(label,nb,"");
+        outAReswVar(node);
+    }
+    // var = {resd} label reservedoubleword number
+    @Override
+    public void caseAResdVar(AResdVar node)
+    {
+        inAResdVar(node);
+        node.getLabel().apply(this);
+        int nb = Integer.parseInt(node.getNumber().getText());
+        pseudoInst = new NasmResd(label,nb,"");
+        outAResdVar(node);
+    }
+    // var = {resq} label reservequadword number
+    @Override
+    public void caseAResqVar(AResqVar node)
+    {
+        inAResqVar(node);
+        node.getLabel().apply(this);
+        int nb = Integer.parseInt(node.getNumber().getText());
+        pseudoInst = new NasmResq(label,nb,"");
+        outAResqVar(node);
+    }
+    // var = {rest} label reservetenbytes number
+    @Override
+    public void caseARestVar(ARestVar node)
+    {
+        inARestVar(node);
+        node.getLabel().apply(this);
+        int nb = Integer.parseInt(node.getNumber().getText());
+        pseudoInst = new NasmRest(label,nb,"");
+        outARestVar(node);
+    }
+
+    // sectext = section text lglobal linst
+    //////////////////////
+    @Override
+    public void caseASectext(ASectext node)
+    {
+        inASectext(node);
+        if(node.getSection() != null)
+        {
+            node.getSection().apply(this);
+        }
+        if(node.getText() != null)
+        {
+            node.getText().apply(this);
+        }
+        if(node.getLglobal() != null)
+        {
+            node.getLglobal().apply(this);
+        }
+        if(node.getLinst() != null)
+        {
+            node.getLinst().apply(this);
+        }
+        outASectext(node);
+    }
+
+    // lglobal = {rec} global label lglobal
+    @Override
+    public void caseARecLglobal(ARecLglobal node)
+    {
+        inARecLglobal(node);
+        if(node.getGlobal() != null)
+        {
+            node.getGlobal().apply(this);
+        }
+        if(node.getLabel() != null)
+        {
+            node.getLabel().apply(this);
+        }
+        if(node.getLglobal() != null)
+        {
+            node.getLglobal().apply(this);
+        }
+        outARecLglobal(node);
+    }
+    // lglobal = {empty}
+    @Override
+    public void caseAEmptyLglobal(AEmptyLglobal node)
+    {
+        inAEmptyLglobal(node);
+        outAEmptyLglobal(node);
+    }
+
+
+    // linst = {rec} inst linst
+    @Override
+    public void caseARecLinst(ARecLinst node)
+    {
+        inARecLinst(node);
+        node.getInst().apply(this);
+        nasm.ajouteInst(inst);
+        label = null;
+        exp = null;
+        size = null;
+        operand = null;
+
+        node.getLinst().apply(this);
+        outARecLinst(node);
+    }
+    
+    // linst = {last} inst
+    @Override
+    public void caseALastLinst(ALastLinst node)
+    {
+        inALastLinst(node);
+        node.getInst().apply(this);
+        nasm.ajouteInst(inst);
+        label = null;
+        exp = null;
+        size = null;
+        operand = null;
+        outALastLinst(node);
+    }
+
+
+    // inst =  {mov}    oplabel mov  ar comma acr
+    @Override
+    public void caseAMovInst(AMovInst node)
+    {
+        inAMovInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+
+        inst = new NasmMov(lineLabel, destination, source, "");
+        outAMovInst(node);
+    }
+
+    // inst =  {push}   oplabel push acr
+    @Override
+    public void caseAPushInst(APushInst node)
+    {
+        inAPushInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmPush(lineLabel, source, "");
+        outAPushInst(node);
+    }
+
+    // inst =  {pop}    oplabel pop  ar
+    @Override
+    public void caseAPopInst(APopInst node)
+    {
+        inAPopInst(node);
+        node.getOplabel().apply(this);
+	NasmLabel lineLabel = label;
+
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        inst = new NasmPop(lineLabel, destination, "");
+        outAPopInst(node);
+    }
+
+    // inst =  {add}    oplabel add  ar comma acr
+    @Override
+    public void caseAAddInst(AAddInst node)
+    {
+        inAAddInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmAdd(lineLabel, destination, source, "");
+        outAAddInst(node);
+    }
+
+    // inst =  {sub}    oplabel sub  ar comma acr
+    @Override
+    public void caseASubInst(ASubInst node)
+    {
+        inASubInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmSub(lineLabel, destination, source, "");
+        outASubInst(node);
+    }
+
+    // inst =  {imul}   oplabel imul ar comma acr
+    @Override
+    public void caseAImulInst(AImulInst node)
+    {
+        inAImulInst(node);
+        node.getOplabel().apply(this);
+	        NasmLabel lineLabel = label;
+
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmMul(lineLabel, destination, source, "");
+        outAImulInst(node);
+    }
+
+    // inst =  {idiv}   oplabel idiv ar
+    @Override
+    public void caseAIdivInst(AIdivInst node)
+    {
+        inAIdivInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmDiv(lineLabel, source, "");
+        outAIdivInst(node);
+    }
+
+    // inst =  {and}    oplabel and  ar comma acr
+    @Override
+    public void caseAAndInst(AAndInst node)
+    {
+        inAAndInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = label;
+        inst = new NasmOr(lineLabel, destination, source, "");
+        outAAndInst(node);
+    }
+
+    // inst =  {or}     oplabel or   ar comma acr
+    @Override
+    public void caseAOrInst(AOrInst node)
+    {
+        inAOrInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmOr(lineLabel, destination, source, "");
+        outAOrInst(node);
+    }
+
+    // inst =  {xor}    oplabel xor  ar comma acr
+    @Override
+    public void caseAXorInst(AXorInst node)
+    {
+        inAXorInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmXor(lineLabel, destination, source, "");
+        outAXorInst(node);
+    }
+
+    // inst =  {not}    oplabel not  ar
+    @Override
+    public void caseANotInst(ANotInst node)
+    {
+        inANotInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        inst = new NasmNot(lineLabel, destination, "");
+        outANotInst(node);
+    }
+
+    // inst =  {cmp}    oplabel cmp  ar comma acr
+    @Override
+    public void caseACmpInst(ACmpInst node)
+    {
+        inACmpInst(node);
+	node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getAr().apply(this);
+        NasmOperand destination = operand;
+        node.getAcr().apply(this);
+        NasmOperand source = operand;
+        inst = new NasmCmp(lineLabel, destination, source, "");
+        outACmpInst(node);
+    }
+
+    // inst =  {jmp}    oplabel jmp  label
+    @Override
+    public void caseAJmpInst(AJmpInst node)
+    {
+        inAJmpInst(node);
+	node.getOplabel().apply(this);
+        NasmOperand lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJmp(lineLabel, jumpTo, "");
+        outAJmpInst(node);
+    }
+
+    // inst =  {je}     oplabel je   label
+    @Override
+    public void caseAJeInst(AJeInst node)
+    {
+        inAJeInst(node);
+	node.getOplabel().apply(this);
+        NasmOperand lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJe(lineLabel, jumpTo, "");
+        outAJeInst(node);
+    }
+
+    // inst =  {jne}    oplabel jne  label
+    @Override
+    public void caseAJneInst(AJneInst node)
+    {
+        inAJneInst(node);
+	node.getOplabel().apply(this);
+        NasmOperand lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJne(lineLabel, jumpTo, "");
+   }
+
+    // inst =  {jg}     oplabel jg   label
+    @Override
+    public void caseAJgInst(AJgInst node)
+    {
+        inAJgInst(node);
+	node.getOplabel().apply(this);
+	NasmOperand lineLabel = label;
+
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJg(lineLabel, jumpTo, "");
+        outAJgInst(node);
+    }
+
+    // inst =  {jge}    oplabel jge  label
+    @Override
+    public void caseAJgeInst(AJgeInst node)
+    {
+        inAJgeInst(node);
+	node.getOplabel().apply(this);
+        NasmOperand lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJge(lineLabel, jumpTo, "");
+        outAJgeInst(node);
+    }
+
+    // inst =  {jl}     oplabel jl   label
+    @Override
+    public void caseAJlInst(AJlInst node)
+    {
+        inAJlInst(node);
+	node.getOplabel().apply(this);
+        NasmOperand lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmJl(lineLabel, jumpTo, "");
+        outAJlInst(node);
+    }
+
+    // inst =  {call}   oplabel call label
+    @Override
+    public void caseACallInst(ACallInst node)
+    {
+        inACallInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        node.getLabel().apply(this);
+        NasmOperand jumpTo = label;
+        inst = new NasmCall(lineLabel, jumpTo, "");
+        outACallInst(node);
+    }
+
+    // inst =  {ret}    oplabel ret
+    @Override
+    public void caseARetInst(ARetInst node)
+    {
+        inARetInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        inst = new NasmRet(lineLabel, "");
+        outARetInst(node);
+    }
+
+    // inst =  {inter}  oplabel int
+    @Override
+    public void caseAInterInst(AInterInst node)
+    {
+        inAInterInst(node);
+        node.getOplabel().apply(this);
+        NasmLabel lineLabel = label;
+        inst = new NasmInt(lineLabel, "");
+        outAInterInst(node);
+    }
+
+    // acr = {address} address
+    @Override
+    public void caseAAddressAcr(AAddressAcr node)
+    {
+        inAAddressAcr(node);
+        if(node.getAddress() != null)
+        {
+            node.getAddress().apply(this);
+        }
+        outAAddressAcr(node);
+    }
+
+    // acr = {numconst} numconst
+    @Override
+    public void caseANumconstAcr(ANumconstAcr node)
+    {
+        inANumconstAcr(node);
+        if(node.getNumconst() != null)
+        {
+            node.getNumconst().apply(this);
+        }
+        outANumconstAcr(node);
+    }
+
+    // acr = {register} register
+    @Override
+    public void caseARegisterAcr(ARegisterAcr node)
+    {
+        inARegisterAcr(node);
+        if(node.getRegister() != null)
+        {
+            node.getRegister().apply(this);
+        }
+        outARegisterAcr(node);
+    }
+
+
+    // ar = {address} address
+    @Override
+    public void caseAAddressAr(AAddressAr node)
+    {
+        inAAddressAr(node);
+        if(node.getAddress() != null)
+        {
+            node.getAddress().apply(this);
+        }
+        outAAddressAr(node);
+    }
+
+    // ar = {register} register
+    @Override
+    public void caseARegisterAr(ARegisterAr node)
+    {
+        inARegisterAr(node);
+        if(node.getRegister() != null)
+        {
+            node.getRegister().apply(this);
+        }
+        outARegisterAr(node);
+    }
+    
+    // address = opsizeof brackopen exp brackclose
+    @Override
+    public void caseAAddress(AAddress node)
+    {
+        inAAddress(node);
+        node.getOpsizeof().apply(this);
+        NasmSize sizeof = size;
+        node.getExp().apply(this);
+        NasmExp val = exp;
+        operand = new NasmAddress(val, sizeof);
+        outAAddress(node);
+    }
+
+
+    // opsizeof = {byte} byte
+    @Override
+    public void caseAByteOpsizeof(AByteOpsizeof node)
+    {
+        inAByteOpsizeof(node);
+        size = NasmSize.BYTE;
+        outAByteOpsizeof(node);
+    }
+
+    // opsizeof = {word} word
+    @Override
+    public void caseAWordOpsizeof(AWordOpsizeof node)
+    {
+        inAWordOpsizeof(node);
+        size = NasmSize.WORD;
+        outAWordOpsizeof(node);
+    }
+
+    // opsizeof = {dword} dword
+    @Override
+    public void caseADwordOpsizeof(ADwordOpsizeof node)
+    {
+        inADwordOpsizeof(node);
+        size = NasmSize.DWORD;
+        outADwordOpsizeof(node);
+    }
+
+    // opsizeof = {empty}
+    @Override
+    public void caseAEmptyOpsizeof(AEmptyOpsizeof node)
+    {
+        inAEmptyOpsizeof(node);
+        size = NasmSize.UNDEFINED;
+        outAEmptyOpsizeof(node);
+    }
+
+    // exp = {plus}  exp plus exp1
+    @Override
+    public void caseAPlusExp(APlusExp node)
+    {
+        inAPlusExp(node);
+        node.getExp().apply(this);
+        NasmExp op1 = exp;
+        node.getExp1().apply(this);
+        NasmExp op2 = exp;
+        exp = new NasmExpPlus(op1, op2);
+        outAPlusExp(node);
+    }
+
+    // exp = {minus} exp minus exp1
+    @Override
+    public void caseAMinusExp(AMinusExp node)
+    {
+        inAMinusExp(node);
+        node.getExp().apply(this);
+        NasmExp op1 = exp;
+        node.getExp1().apply(this);
+        NasmExp op2 = exp;
+        exp = new NasmExpMinus(op1, op2);
+        outAMinusExp(node);
+    }
+
+    // exp = {next}  exp1
+    @Override
+    public void caseANextExp(ANextExp node)
+    {
+        inANextExp(node);
+        if(node.getExp1() != null)
+        {
+            node.getExp1().apply(this);
+        }
+        outANextExp(node);
+    }
+
+
+    // exp1 = {times} exp1 times exp2
+    @Override
+    public void caseATimesExp1(ATimesExp1 node)
+    {
+        inATimesExp1(node);
+        node.getExp1().apply(this);
+        NasmExp op1 = exp;
+        node.getExp2().apply(this);
+        NasmExp op2 = exp;
+        exp = new NasmExpTimes(op1, op2);
+        outATimesExp1(node);
+    }
+
+    // exp1 = {next}  exp2
+    @Override
+    public void caseANextExp1(ANextExp1 node)
+    {
+        inANextExp1(node);
+        if(node.getExp2() != null)
+        {
+            node.getExp2().apply(this);
+        }
+        outANextExp1(node);
+    }
+
+
+    // exp2 = {label} label
+    @Override
+    public void caseALabelExp2(ALabelExp2 node)
+    {
+        inALabelExp2(node);
+        node.getLabel().apply(this);
+        exp = label;
+        outALabelExp2(node);
+    }
+
+    // exp2 = {numconst} numconst
+    @Override
+    public void caseANumconstExp2(ANumconstExp2 node)
+    {
+        inANumconstExp2(node);
+        node.getNumconst().apply(this);
+        exp = (NasmConstant)operand;
+        outANumconstExp2(node);
+    }
+
+    // exp2 = {register} register
+    @Override
+    public void caseARegisterExp2(ARegisterExp2 node)
+    {
+        inARegisterExp2(node);
+        node.getRegister().apply(this);
+        exp = (NasmRegister) operand;
+        outARegisterExp2(node);
+    }
+
+    // numconst = number
+    @Override
+    public void caseANumconst(ANumconst node)
+    {
+        inANumconst(node);
+        operand = new NasmConstant(Integer.parseInt(node.getNumber().getText()));
+        outANumconst(node);
+    }
+
+    // register = {temp} prefix_register number
+    @Override
+    public void caseATempRegister(ATempRegister node)
+    {
+        inATempRegister(node);
+	int regNb = Integer.parseInt(node.getNumber().getText());
+	if (regNb > nasm.getTempCounter())
+	    nasm.setTempCounter(regNb);
+        operand = new NasmRegister(regNb);
+        outATempRegister(node);
+    }
+
+    // register = {eax} eax
+    @Override
+    public void caseAEaxRegister(AEaxRegister node)
+    {
+        inAEaxRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_EAX);
+        operand = reg;
+        outAEaxRegister(node);
+    }
+
+    // register = {ebx} ebx
+    @Override
+    public void caseAEbxRegister(AEbxRegister node)
+    {
+        inAEbxRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_EBX);
+        operand = reg;
+        outAEbxRegister(node);
+    }
+
+    // register = {ecx} ecx
+    @Override
+    public void caseAEcxRegister(AEcxRegister node)
+    {
+        inAEcxRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_ECX);
+        operand = reg;
+        outAEcxRegister(node);
+    }
+
+    // register = {edx} edx
+    @Override
+    public void caseAEdxRegister(AEdxRegister node)
+    {
+        inAEdxRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_EDX);
+        operand = reg;
+        outAEdxRegister(node);
+    }
+
+    // register = {ebp} ebp
+    @Override
+    public void caseAEbpRegister(AEbpRegister node)
+    {
+        inAEbpRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_EBP);
+        operand = reg;
+        outAEbpRegister(node);
+    }
+
+    // register = {esp} esp
+    @Override
+    public void caseAEspRegister(AEspRegister node)
+    {
+        inAEspRegister(node);
+        NasmRegister reg  = new NasmRegister(0);
+        reg.colorRegister(Nasm.REG_ESP);
+        operand = reg;
+        outAEspRegister(node);
+    }
+
+
+    // oplabel = {label} label semicol
+    @Override
+    public void caseALabelOplabel(ALabelOplabel node)
+    {
+        inALabelOplabel(node);
+        node.getLabel().apply(this);
+        outALabelOplabel(node);
+    }
+
+    // oplabel = {empty}
+    @Override
+    public void caseAEmptyOplabel(AEmptyOplabel node)
+    {
+        inAEmptyOplabel(node);
+        label = null;
+        outAEmptyOplabel(node);
+    }
+
+    // label = id
+    @Override
+    public void caseALabel(ALabel node)
+    {
+        inALabel(node);
+        label = new NasmLabel(node.getId().getText());
+        outALabel(node);
+    }
+}
+
+
+
diff --git a/src/nasm/Nasm.java b/src/nasm/Nasm.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bd34e4dffb1a3c4d05b5b030653882f6aee44da
--- /dev/null
+++ b/src/nasm/Nasm.java
@@ -0,0 +1,172 @@
+package nasm;
+import java.util.*;
+import java.io.*;
+import ts.*;
+    
+public class Nasm{
+    public List<NasmInst> sectionText;
+    public List<NasmPseudoInst> sectionBss;
+    protected int tempCounter = 0;
+    Ts tableGlobale;
+    public static int REG_EAX = 0;
+    public static int REG_EBX = 1;
+    public static int REG_ECX = 2;
+    public static int REG_EDX = 3;
+    public static int REG_ESP = 4;
+    public static int REG_EBP = 5;
+    public static int REG_UNK = 6;
+    //    public static int NB_PREDEFINED_REG = 7;
+
+
+    public Nasm(Ts tableGlobale){
+	this.tableGlobale = tableGlobale;
+	this.sectionBss = new ArrayList<NasmPseudoInst>();
+	this.sectionText = new ArrayList<NasmInst>();
+	populateSectionBss(tableGlobale);
+    }
+
+    public Nasm(){
+	this.sectionBss = new ArrayList<NasmPseudoInst>();
+	this.sectionText = new ArrayList<NasmInst>();
+    }
+
+    public int getTempCounter(){return this.tempCounter;}
+    public int setTempCounter(int c){return this.tempCounter = c;}
+    
+    public void ajoutePseudoInst(NasmPseudoInst pseudoInst){
+	this.sectionBss.add(pseudoInst);
+    }
+    
+    public void ajouteInst(NasmInst inst){
+	if(inst instanceof NasmMov && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){
+	    NasmRegister newReg = newRegister();
+	    this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); 
+	    this.sectionText.add(new NasmMov(null, inst.destination, newReg, "on passe par un registre temporaire"));
+	    return;
+	}
+	if(inst instanceof NasmAdd && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){
+	    NasmRegister newReg = newRegister();
+	    this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); 
+	    this.sectionText.add(new NasmAdd(null, inst.destination, newReg, "on passe par un registre temporaire"));
+	    return;
+	}
+	if(inst instanceof NasmSub && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){
+	    NasmRegister newReg = newRegister();
+	    this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); 
+	    this.sectionText.add(new NasmSub(null, inst.destination, newReg, "on passe par un registre temporaire"));
+	    return;
+	}
+	if(inst instanceof NasmMul && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){
+	    NasmRegister newReg = newRegister();
+	    this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); 
+	    this.sectionText.add(new NasmMul(null, inst.destination, newReg, "on passe par un registre temporaire"));
+	    return;
+	}
+
+	
+	//	if(inst instanceof NasmCmp && inst.destination instanceof NasmConstant && inst.source instanceof NasmConstant){
+	if(inst instanceof NasmCmp
+	   && (inst.destination instanceof NasmConstant
+	       || (inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress))){
+		NasmRegister newReg = newRegister();
+		this.sectionText.add(new NasmMov(inst.label, newReg, inst.destination, inst.comment)); 
+		this.sectionText.add(new NasmCmp(null, newReg, inst.source, "on passe par un registre temporaire"));
+		return;
+	    }
+	
+	this.sectionText.add(inst);
+    }
+
+    public NasmRegister newRegister(){
+	return new NasmRegister(tempCounter++);
+    }
+
+    public void populateSectionBss(Ts tableGlobale){
+	ajoutePseudoInst(new NasmResb(new NasmLabel("sinput"), 255, "reserve a 255 byte space in memory for the users input string"));
+	Set< Map.Entry< String, TsItemVar> > st = tableGlobale.variables.entrySet();    
+	for (Map.Entry< String, TsItemVar> me:st){
+	    TsItemVar tsItem = me.getValue(); 
+	    String identif = me.getKey();
+	    if(tsItem instanceof TsItemVarSimple)
+		ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.type.taille(), "variable globale"));
+	    if(tsItem instanceof TsItemVarTab)
+		ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.type.taille() * ((TsItemVarTab)tsItem).taille, "variable globale"));
+	    //	    ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.taille*4, "variable globale"));
+	}
+    }
+
+
+    public void affichePreNasm(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".pre-nasm";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	affiche(out);
+    }
+
+    public void afficheNasm(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".nasm";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+	affiche(out);
+    }
+
+    public void affiche(PrintStream out){
+	out.println("%include\t'io.asm'\n");
+	out.println("section\t.bss");
+    	Iterator<NasmPseudoInst> iter = this.sectionBss.iterator();
+    	while(iter.hasNext()){
+    	    out.println(iter.next());
+    	}
+	
+	out.println("\nsection\t.text");
+	out.println("global _start");
+	out.println("_start:");
+    	Iterator<NasmInst> iter2 = this.sectionText.iterator();
+    	while(iter2.hasNext()){
+    	    out.println(iter2.next());
+    	}
+    }
+}
+/*
+    public void affichePreambule(PrintStream out)
+    {
+	out.println("%include\t'io.asm'\n");
+	out.println("section\t.bss");
+	out.println("sinput:\tresb\t255\t;reserve a 255 byte space in memory for the users input string");
+
+
+	Set< Map.Entry< String, TsItemVar> > st = tableGlobale.variables.entrySet();    
+	for (Map.Entry< String, TsItemVar> me:st){
+	    TsItemVar tsItem = me.getValue(); 
+	    String identif = me.getKey();
+	    out.println(identif + " :\tresd\t" + tsItem.taille * 4);
+	}
+	out.println("\nsection\t.text");
+	out.println("global _start");
+	out.println("_start:");
+    }
+
+
+    */
diff --git a/src/nasm/NasmAdd.java b/src/nasm/NasmAdd.java
new file mode 100644
index 0000000000000000000000000000000000000000..340d0df41e5daa194a3f5124db85821edb4ac527
--- /dev/null
+++ b/src/nasm/NasmAdd.java
@@ -0,0 +1,25 @@
+package nasm;
+
+public class NasmAdd extends NasmInst {
+    
+    public NasmAdd(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "add", this.destination, this.source, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmAddress.java b/src/nasm/NasmAddress.java
new file mode 100644
index 0000000000000000000000000000000000000000..f81e92aa623aae32aafa2b73d3d27660d3831913
--- /dev/null
+++ b/src/nasm/NasmAddress.java
@@ -0,0 +1,26 @@
+package nasm;
+
+public class NasmAddress extends NasmOperand {
+
+    public NasmExp val;
+    public NasmSize size;
+
+    public NasmAddress(NasmExp val, NasmSize size){
+    this.val = val;
+    this.size = size;
+    }
+
+    public String toString(){
+        return this.size.toString() + " [" + this.val.toString() + "]";
+    }
+
+    public boolean isGeneralRegister(){
+	return false;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+	}
+
+
+}
diff --git a/src/nasm/NasmAnd.java b/src/nasm/NasmAnd.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4c32e30c104c706c7509f928ad6a9a24f586ad1
--- /dev/null
+++ b/src/nasm/NasmAnd.java
@@ -0,0 +1,24 @@
+package nasm;
+
+public class NasmAnd extends NasmInst {
+    
+    public NasmAnd(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "and", this.destination, this.source, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmCall.java b/src/nasm/NasmCall.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7a43e1e4cd8be9486944df4e20fa11a6dab5ed7
--- /dev/null
+++ b/src/nasm/NasmCall.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmCall extends NasmInst {
+    
+    public NasmCall(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "call", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmCmp.java b/src/nasm/NasmCmp.java
new file mode 100644
index 0000000000000000000000000000000000000000..6926d8f142289e1d1dfb869d968dfa945db15abe
--- /dev/null
+++ b/src/nasm/NasmCmp.java
@@ -0,0 +1,23 @@
+package nasm;
+
+public class NasmCmp extends NasmInst {
+    
+    public NasmCmp(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	srcUse= true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "cmp", this.destination, this.source, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmConstant.java b/src/nasm/NasmConstant.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f6a74991e9ae7c1ad6a9ec17c9c90225500aec6
--- /dev/null
+++ b/src/nasm/NasmConstant.java
@@ -0,0 +1,28 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmConstant extends NasmOperand implements NasmExp{
+    public int val;
+    public NasmConstant(int val){
+	this.val = val;
+    }
+
+    public String toString(){
+	return Integer.toString(this.val);
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	return registerList;
+    }
+}
diff --git a/src/nasm/NasmDiv.java b/src/nasm/NasmDiv.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3cc45f789610566e0dba0e60c68716a24d0c510
--- /dev/null
+++ b/src/nasm/NasmDiv.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmDiv extends NasmInst {
+    
+    public NasmDiv(NasmOperand label, NasmOperand source, String comment){
+	srcUse = true;
+	this.label = label;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	    return super.formatInst(this.label, "idiv", this.source, null, this.comment);
+	}
+}
diff --git a/src/nasm/NasmEmpty.java b/src/nasm/NasmEmpty.java
new file mode 100644
index 0000000000000000000000000000000000000000..808f6903d9a5735a2a15625226377d0c0fa7f996
--- /dev/null
+++ b/src/nasm/NasmEmpty.java
@@ -0,0 +1,18 @@
+package nasm;
+
+public class NasmEmpty extends NasmInst {
+    
+    public NasmEmpty(NasmOperand label, String comment){
+	this.label = label;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "", null, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmEval.java b/src/nasm/NasmEval.java
new file mode 100644
index 0000000000000000000000000000000000000000..3178a3cc6673368d23b6d5b3b23dd2e7c003b9b9
--- /dev/null
+++ b/src/nasm/NasmEval.java
@@ -0,0 +1,410 @@
+package nasm;
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import util.Memory;
+
+/*
+This class emulates pre-nasm and nasm code for x86-64 architecture.
+It handles only integers on 4 bytes and have unlimited register.
+ */
+
+public class NasmEval implements NasmVisitor<Integer>{
+    private Nasm code;
+    private int dataSize = 0;
+
+    private int regNb;
+    private HashMap<String, Integer> labelToAddress;
+    private Memory memory;
+    private boolean stop;
+    private ArrayList<Integer> output;
+
+    // registers
+    private int[] registers;
+    
+    private int ebp;
+    private int eip = 0;
+    private int eax = 0; 
+    private int ebx = 0; 
+    private int ecx = 0; 
+    private int edx = 0; 
+    
+    //flags
+    // Carry Flag -> not used
+    private boolean CF = false;
+    // Parity Flag -> not used
+    private boolean PF = false;
+    // Zero Flag
+    private boolean ZF = false;
+    // Sign Flag
+    private boolean SF = false;
+    // Overflow Flag -> not used
+    private boolean OF = false;
+	
+    private int verboseLevel;
+
+    public NasmEval(Nasm code, int stackSize, int verboseLevel){
+        this.code = code;
+	this.verboseLevel = verboseLevel;
+	regNb = this.code.getTempCounter();
+        registers = new int[regNb+1];
+        eip = 0;
+        stop = false;
+
+        output = new ArrayList<>();
+	labelToAddress = new HashMap<>();
+
+	associateLabelToAddress();
+       	memory = new Memory(dataSize, stackSize);
+	
+        while(!stop && eip < code.sectionText.size()){
+	    NasmInst inst = this.code.sectionText.get(eip);
+	    if(verboseLevel > 0){
+		System.out.println("--------------------------------------");
+
+		PrintGlobalVariables();
+		//		System.out.println("eip = " + eip + "\tesp = " + memory.getTopInt() + "\t ebp = " + ebp);
+		System.out.println("eip = " + eip + "\tesp = " + memory.esp + "\t ebp = " + ebp);
+		System.out.println("eax = " + eax + "\tebx = " + ebx + "\tecx = " + ecx + "\tedx = " + edx);
+		System.out.println("CF = " + CF + "\tPF = " + PF + "\tZF = " + ZF + "\tSF = " + SF + "\tOF = " + OF);
+		printRegisters();
+		System.out.print("PILE : \t");
+		memory.printStack();
+		System.out.println(inst);
+	    }
+            eip = inst.accept(this);
+        }
+	//	displayOutput();
+    }
+
+    public void PrintGlobalVariables(){
+    for (HashMap.Entry<String, Integer> e : labelToAddress.entrySet())
+
+	    //   	System.out.println("[" + e.getValue() + "]\t" + e.getKey() + " = " + memory.readInt(e.getValue()));
+	System.out.println(e.getKey() + " = " + memory.readInt(e.getValue()) + " adr: " + e.getValue());
+
+    }
+	
+    public void printRegisters(){
+	for(int i=0; i < regNb; i++){
+	    System.out.print("r" + i + ":" + registers[i] + "\t");
+	}
+	//	System.out.println();
+    }
+
+    public void displayOutput(){
+        for(var val : output)
+            System.out.println(val);
+    }
+
+    public void displayOutput(String outputFile) throws FileNotFoundException {
+        var out = new PrintStream(outputFile);
+        for(var val : output)
+            out.println(val);
+    }
+
+    private void associateLabelToAddress(){
+        var instructions = code.sectionText;
+	// associate labels to line numbers
+        for(int lineNb = 0; lineNb <instructions.size(); lineNb++){
+            if(instructions.get(lineNb).label != null) {
+                var label = (NasmLabel)instructions.get(lineNb).label;
+                labelToAddress.put(label.val, lineNb);
+            }
+        }
+	// compute addresses of global variables and associate them to labels
+	for(int i = 0; i < code.sectionBss.size(); i++){
+	    NasmPseudoInst pseudoInst = this.code.sectionBss.get(i);
+	    labelToAddress.put(pseudoInst.label.val, dataSize);
+	    //	    System.out.println("var :" + pseudoInst.label.val + " address = " + dataSize);
+	    dataSize += pseudoInst.nb * pseudoInst.sizeInBytes;
+	}
+    }
+
+    /*------------------------------------------*/
+    private void copy(NasmOperand dest, int value){
+	if(dest instanceof NasmAddress)
+	    copy((NasmAddress) dest, value);
+	else if(dest instanceof NasmRegister)
+	    copy((NasmRegister) dest, value);
+    }
+    
+    private void copy(NasmAddress dest, int value){
+	int address = dest.val.accept(this);
+	memory.writeInt(address, value);
+    }
+    
+
+    private void copy(NasmRegister dest, int value){
+	writeToRegister(dest, value);
+    }
+
+    /*------------------------------------------*/
+
+    // return value stored in regiter
+    private int readFromRegister(NasmRegister reg){
+	if(reg.color == Nasm.REG_EAX)
+	    return eax;
+	if (reg.color == Nasm.REG_EBX)
+	    return ebx;
+	if (reg.color == Nasm.REG_ECX)
+	    return ecx;
+	if (reg.color == Nasm.REG_EDX)
+	    return edx;
+	if (reg.color == Nasm.REG_ESP)
+	    return memory.esp;
+	if (reg.color == Nasm.REG_EBP)
+	    return ebp;
+	else
+	    return registers[reg.val];
+
+    }
+    // write in a register
+    
+    private void writeToRegister(NasmRegister reg, int value){
+	if(reg.color == Nasm.REG_EAX)
+	    eax = value;
+	else if (reg.color == Nasm.REG_EBX)
+	    ebx = value;
+	else if (reg.color == Nasm.REG_ECX)
+	    ecx = value;
+	else if (reg.color == Nasm.REG_EDX)
+	    edx = value;
+	else if (reg.color == Nasm.REG_ESP)
+	    memory.esp = value;
+	else if (reg.color == Nasm.REG_EBP)
+	    ebp = value;
+	else
+	    registers[reg.val] = value;
+    }
+
+    /* visit address -> return the value stored at this address */
+    @Override
+    public Integer visit(NasmAddress adr) {
+	return memory.readInt(adr.val.accept(this));
+    }
+
+    /* visit register -> return the value stored in the register */
+    @Override
+    public Integer visit(NasmRegister operand) {
+	if(operand.color == Nasm.REG_EAX)
+	    return eax;
+	if (operand.color == Nasm.REG_EBX)
+	    return ebx;
+	if (operand.color == Nasm.REG_ECX)
+	    return ecx;
+	if (operand.color == Nasm.REG_EDX)
+	    return edx;
+	if (operand.color == Nasm.REG_ESP)
+	    return memory.esp;
+	if (operand.color == Nasm.REG_EBP)
+	    return ebp;
+	else
+	    return registers[operand.val];
+    }
+
+    /* visit constant -> return value of the constant */
+    @Override
+    public Integer visit(NasmConstant operand) {
+        return operand.val;
+    }
+
+    /* visit label -> return address corresponding to the label */
+    @Override
+    public Integer visit(NasmLabel operand) {
+        if(labelToAddress.containsKey(operand.val))
+	    return labelToAddress.get(operand.val);
+	else
+	    throw new RuntimeException("label " + operand.val + "does not correspond to address");
+    }
+
+
+    /* visiting an instruction returns new value of eip */
+    /* arithmetic operations */
+    
+    @Override
+    public Integer visit(NasmAdd inst) {
+	copy(inst.destination, inst.source.accept(this) + inst.destination.accept(this));
+        return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmSub inst) {
+        copy(inst.destination, inst.destination.accept(this) - inst.source.accept(this));
+	return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmMul inst) {
+        copy(inst.destination, inst.source.accept(this) * inst.destination.accept(this));
+	return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmDiv inst) {
+        var divisor  = inst.source.accept(this);
+        var temp = eax;
+        eax = temp / divisor;
+        edx = temp % divisor;
+	return eip + 1;
+    }
+
+    /* logical operations */
+    @Override
+    public Integer visit(NasmOr inst) {
+        copy(inst.destination, inst.source.accept(this) | inst.destination.accept(this));
+        return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmNot inst) {
+        copy(inst.destination, ~ inst.destination.accept(this));
+        return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmXor inst) {
+        copy(inst.destination, inst.source.accept(this) ^ inst.destination.accept(this));
+	return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmAnd inst) {
+        copy(inst.destination, inst.source.accept(this) & inst.destination.accept(this));
+	return eip + 1;
+    }
+
+    /* function call */
+    @Override
+    public Integer visit(NasmCall inst) {
+        if(inst.address instanceof NasmLabel && ((NasmLabel)inst.address).val.equals("iprintLF")){
+            output.add(eax);
+	    return eip + 1;
+	}
+	memory.pushInt(eip);
+	return inst.address.accept(this);
+    }
+
+    /* comparison */
+    @Override
+    public Integer visit(NasmCmp inst) {
+        int valSrc = inst.source.accept(this);
+        int valDest = inst.destination.accept(this);
+        ZF = (valDest == valSrc)? true : false;
+	SF = (valDest < valSrc)? true : false;
+        return eip + 1;
+    }
+    
+    /* jumps */
+    @Override
+    public Integer visit(NasmJe inst) {
+        return (ZF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJle inst) {
+        return (ZF || SF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJne inst) {
+        return (!ZF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJge inst) {
+        return (ZF || !SF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJl inst) {
+	return (!ZF && SF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJg inst) {
+        return (!ZF || SF)? inst.address.accept(this) : eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmJmp inst) {
+        return inst.address.accept(this);
+    }
+
+    @Override
+    public Integer visit(NasmPop inst) {
+        copy(inst.destination, memory.popInt());
+	return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmPush inst) {
+        memory.pushInt(inst.source.accept(this));
+        return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmRet inst) {
+        return memory.popInt() + 1;
+    }
+
+    @Override
+    public Integer visit(NasmMov inst) {
+        copy(inst.destination, inst.source.accept(this));
+	return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmInt inst) {
+        if(eax == 1)
+            stop = true;
+        return eip + 1;
+    }
+
+    @Override
+    public Integer visit(NasmInst inst) {
+        return 0;
+    }
+
+    @Override
+    public Integer visit(NasmEmpty inst) {
+        return eip + 1;
+    }
+
+    public Integer visit(NasmResb pseudoInst){return 0;}
+    public Integer visit(NasmResw pseudoInst){return 0;}
+    public Integer visit(NasmResd pseudoInst){return 0;}
+    public Integer visit(NasmResq pseudoInst){return 0;}
+    public Integer visit(NasmRest pseudoInst){return 0;}
+
+    /* visit expression -> returns an address */
+    
+    public Integer visit(NasmExp exp) { /* c'est moche, il faudrait modifier ça !! */
+	if(exp instanceof NasmLabel)
+	    return ((NasmLabel)exp).accept(this);
+
+	if(exp instanceof NasmRegister)
+	    return ((NasmRegister)exp).accept(this);
+
+	if(exp instanceof NasmLabel)
+	    return ((NasmLabel)exp).accept(this);
+
+	if(exp instanceof NasmConstant)
+	    return ((NasmConstant)exp).accept(this);
+
+	if(exp instanceof NasmExpPlus)
+	    return ((NasmExpPlus)exp).accept(this);
+
+	if(exp instanceof NasmExpMinus)
+	    return ((NasmExpMinus)exp).accept(this);
+
+	//	if(exp instanceof NasmExpTimes)
+	    return ((NasmExpTimes)exp).accept(this);
+    }
+    public Integer visit(NasmExpPlus exp) {return exp.op1.accept(this) + exp.op2.accept(this);}
+    public Integer visit(NasmExpMinus exp){return exp.op1.accept(this) - exp.op2.accept(this);}
+    public Integer visit(NasmExpTimes exp){return exp.op1.accept(this) * exp.op2.accept(this);}
+
+
+}
diff --git a/src/nasm/NasmExp.java b/src/nasm/NasmExp.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e51c1d1d92095a3dcdbd99ea4cb2831e32857bc
--- /dev/null
+++ b/src/nasm/NasmExp.java
@@ -0,0 +1,11 @@
+package nasm;
+import java.util.ArrayList;
+
+public interface NasmExp {
+    //    public boolean isStackAddress();
+    public ArrayList<NasmRegister> getRegisters();
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList);
+
+
+    public <T> T accept(NasmVisitor <T> visitor);
+}
diff --git a/src/nasm/NasmExpMinus.java b/src/nasm/NasmExpMinus.java
new file mode 100644
index 0000000000000000000000000000000000000000..419c1c167e89e2cf0d1ed5a4236b8e9c160d0020
--- /dev/null
+++ b/src/nasm/NasmExpMinus.java
@@ -0,0 +1,34 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmExpMinus implements NasmExp{
+    public NasmExp op1;
+    public NasmExp op2;
+
+    public NasmExpMinus(NasmExp op1, NasmExp op2){
+        this.op1 = op1;
+        this.op2 = op2;
+    }
+
+    @Override
+    public String toString() {
+        return op1.toString() + "-" + op2.toString();
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	this.op1.getRegisters(registerList);
+	this.op2.getRegisters(registerList);
+	return registerList;
+    }
+}
diff --git a/src/nasm/NasmExpPlus.java b/src/nasm/NasmExpPlus.java
new file mode 100644
index 0000000000000000000000000000000000000000..440d310d3fa1b3e8b46c6f9b06d01252eb9d7587
--- /dev/null
+++ b/src/nasm/NasmExpPlus.java
@@ -0,0 +1,34 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmExpPlus implements NasmExp{
+    public NasmExp op1;
+    public NasmExp op2;
+
+    public NasmExpPlus(NasmExp op1, NasmExp op2){
+        this.op1 = op1;
+        this.op2 = op2;
+    }
+
+    @Override
+    public String toString() {
+        return op1.toString() + "+" + op2.toString();
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	this.op1.getRegisters(registerList);
+	this.op2.getRegisters(registerList);
+	return registerList;
+    }
+}
diff --git a/src/nasm/NasmExpTimes.java b/src/nasm/NasmExpTimes.java
new file mode 100644
index 0000000000000000000000000000000000000000..efc07f3a498d2a90997e3f572916b83daa864394
--- /dev/null
+++ b/src/nasm/NasmExpTimes.java
@@ -0,0 +1,34 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmExpTimes implements NasmExp{
+    public NasmExp op1;
+    public NasmExp op2;
+
+    public NasmExpTimes(NasmExp op1, NasmExp op2){
+        this.op1 = op1;
+        this.op2 = op2;
+    }
+
+    @Override
+    public String toString() {
+        return op1.toString() + "+" + op2.toString();
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	this.op1.getRegisters(registerList);
+	this.op2.getRegisters(registerList);
+	return registerList;
+    }
+}
diff --git a/src/nasm/NasmInst.java b/src/nasm/NasmInst.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d81f8f999d766a2d0cf7bf6c766415b14e274a7
--- /dev/null
+++ b/src/nasm/NasmInst.java
@@ -0,0 +1,36 @@
+package nasm;
+
+public abstract class NasmInst{
+    public NasmOperand label = null;
+    public NasmOperand destination = null;
+    public NasmOperand source = null;
+    public NasmOperand address = null;
+    public boolean destUse = false;
+    public boolean destDef = false;
+    public boolean srcUse = false;
+    public boolean srcDef = false;
+    String comment;
+    
+    void addLabel(String formatInst, NasmOperand label){
+	formatInst += label;
+    }
+    
+    public String formatInst(NasmOperand label, String opcode, NasmOperand arg1, NasmOperand arg2, String comment){
+	String s = "";
+	if(label != null)
+	    s = s + label + " :";
+	s = s + "\t" + opcode;
+	if(arg1 != null)
+		s = s + "\t" + arg1;
+	if(arg2 != null)
+		s = s + ",\t" + arg2;
+	if(comment != null & comment != "")
+	    s = s + "\t;" + comment;
+	return s;
+    }
+
+        public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+}
diff --git a/src/nasm/NasmInt.java b/src/nasm/NasmInt.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e6a5b5114a89be83f45efa6db827197e706f18d
--- /dev/null
+++ b/src/nasm/NasmInt.java
@@ -0,0 +1,18 @@
+package nasm;
+
+public class NasmInt extends NasmInst {
+    
+    public NasmInt(NasmOperand label, String comment){
+	this.label = label;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "int 0x80", null, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJe.java b/src/nasm/NasmJe.java
new file mode 100644
index 0000000000000000000000000000000000000000..e40ab6c72b69d222c43dc8157d301ef43287b585
--- /dev/null
+++ b/src/nasm/NasmJe.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJe extends NasmInst {
+    
+    public NasmJe(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "je", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJg.java b/src/nasm/NasmJg.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f6881c91c9fe8d4a4d0df7b604dc197ab655edc
--- /dev/null
+++ b/src/nasm/NasmJg.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJg extends NasmInst {
+    
+    public NasmJg(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "jg", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJge.java b/src/nasm/NasmJge.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5091cb3a26e3588606edc8916352c825726b767
--- /dev/null
+++ b/src/nasm/NasmJge.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJge extends NasmInst {
+    
+    public NasmJge(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "jge", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJl.java b/src/nasm/NasmJl.java
new file mode 100644
index 0000000000000000000000000000000000000000..5216ba3364e6e7d10cda6a0dcb3b1cbe70158944
--- /dev/null
+++ b/src/nasm/NasmJl.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJl extends NasmInst {
+    
+    public NasmJl(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "jl", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJle.java b/src/nasm/NasmJle.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac84e86eb8b5d827a7d25f457a63d7c9681390c6
--- /dev/null
+++ b/src/nasm/NasmJle.java
@@ -0,0 +1,25 @@
+package nasm;
+
+public class NasmJle extends NasmInst {
+    
+    public NasmJle(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	//	String formatInst
+	//	addLabel(label);
+
+	//return formatInst;
+
+	
+	return super.formatInst(this.label, "jle", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJmp.java b/src/nasm/NasmJmp.java
new file mode 100644
index 0000000000000000000000000000000000000000..62377f126ac55d1ec5600bbcea12cd8b4679be72
--- /dev/null
+++ b/src/nasm/NasmJmp.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJmp extends NasmInst {
+    
+    public NasmJmp(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "jmp", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmJne.java b/src/nasm/NasmJne.java
new file mode 100644
index 0000000000000000000000000000000000000000..06531c879260b981043a8a8b9064c422637da305
--- /dev/null
+++ b/src/nasm/NasmJne.java
@@ -0,0 +1,19 @@
+package nasm;
+
+public class NasmJne extends NasmInst {
+    
+    public NasmJne(NasmOperand label, NasmOperand address, String comment){
+	this.label = label;
+	this.address = address;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "jne", this.address, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmLabel.java b/src/nasm/NasmLabel.java
new file mode 100644
index 0000000000000000000000000000000000000000..85d49095fa53b78c098461e1fdd3c26810172051
--- /dev/null
+++ b/src/nasm/NasmLabel.java
@@ -0,0 +1,28 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmLabel extends NasmOperand implements NasmExp {
+    public String val;
+
+    public NasmLabel(String val){
+	this.val = val;
+    }
+    public String toString(){
+	return this.val;
+    }
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    public boolean isStackAddress(){return false;}
+
+        public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	return registerList;
+    }
+}
diff --git a/src/nasm/NasmMov.java b/src/nasm/NasmMov.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d3d7435b32a56289f9402aa7196f1b7a10aef33
--- /dev/null
+++ b/src/nasm/NasmMov.java
@@ -0,0 +1,22 @@
+package nasm;
+
+public class NasmMov extends NasmInst {
+    
+    public NasmMov(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "mov", this.destination, this.source, this.comment);
+    }
+    
+}
diff --git a/src/nasm/NasmMul.java b/src/nasm/NasmMul.java
new file mode 100644
index 0000000000000000000000000000000000000000..3be1297c361a844e3f1f1ad95b43f94eb4474a03
--- /dev/null
+++ b/src/nasm/NasmMul.java
@@ -0,0 +1,26 @@
+package nasm;
+
+public class NasmMul extends NasmInst {
+    public NasmMul(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    /*    public String toString(){
+	return super.formatInst(this.label, "imul", this.source, null, this.comment);
+	}*/
+
+    public String toString(){
+	return super.formatInst(this.label, "imul", this.destination, this.source, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmNot.java b/src/nasm/NasmNot.java
new file mode 100644
index 0000000000000000000000000000000000000000..c43ddf2cb91445518475e843c70bc0e5ee064da6
--- /dev/null
+++ b/src/nasm/NasmNot.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmNot extends NasmInst {
+    
+    public NasmNot(NasmOperand label, NasmOperand destination, String comment){
+	destUse = true;
+	destDef = true;
+	this.label = label;
+	this.destination = destination;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "not", this.destination, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmOperand.java b/src/nasm/NasmOperand.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fb05ba7c9194420c32219b93cdc0bb8fd1b1ea4
--- /dev/null
+++ b/src/nasm/NasmOperand.java
@@ -0,0 +1,8 @@
+package nasm;
+
+public abstract class NasmOperand {
+    public boolean isGeneralRegister(){
+	return false;
+    }
+    public  abstract <T> T accept(NasmVisitor <T> visitor);
+}
diff --git a/src/nasm/NasmOr.java b/src/nasm/NasmOr.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dd09f3e87601aa305a97b9fbaf4c44741bcfad7
--- /dev/null
+++ b/src/nasm/NasmOr.java
@@ -0,0 +1,24 @@
+package nasm;
+
+public class NasmOr extends NasmInst {
+    
+    public NasmOr(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "or", this.destination, this.source, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmPop.java b/src/nasm/NasmPop.java
new file mode 100644
index 0000000000000000000000000000000000000000..88c46bfbfbd9158a652369c6598b86f18abc993f
--- /dev/null
+++ b/src/nasm/NasmPop.java
@@ -0,0 +1,20 @@
+package nasm;
+
+public class NasmPop extends NasmInst {
+    
+    public NasmPop(NasmOperand label, NasmOperand destination, String comment){
+	destDef = true;
+	this.label = label;
+	this.destination = destination;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "pop", this.destination, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmPseudoInst.java b/src/nasm/NasmPseudoInst.java
new file mode 100644
index 0000000000000000000000000000000000000000..27e14c7935b4d3e1b49f848456552a1d0fbc1f92
--- /dev/null
+++ b/src/nasm/NasmPseudoInst.java
@@ -0,0 +1,28 @@
+package nasm;
+
+public abstract class NasmPseudoInst{
+    public NasmLabel label = null;
+    public int nb = 1;
+    public int sizeInBytes;
+    String comment;
+    
+    void addLabel(String formatInst, NasmOperand label){
+	formatInst += label;
+    }
+    
+    public String formatInst(NasmOperand label, String opcode, int nb, String comment){
+	String s = "";
+	if(label != null)
+	    s = s + label + " :";
+	s = s + "\t" + opcode;
+	s = s + "\t" + nb;
+	if(comment != null)
+	    s = s + "\t;" + comment;
+	return s;
+    }
+
+    /*        public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+	}*/
+
+}
diff --git a/src/nasm/NasmPush.java b/src/nasm/NasmPush.java
new file mode 100644
index 0000000000000000000000000000000000000000..a663634e1517adf6acecac57d8de09365c059836
--- /dev/null
+++ b/src/nasm/NasmPush.java
@@ -0,0 +1,20 @@
+package nasm;
+
+public class NasmPush extends NasmInst {
+    
+    public NasmPush(NasmOperand label, NasmOperand source, String comment){
+	//	srcUse = true;
+	this.label = label;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "push", this.source, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmRegister.java b/src/nasm/NasmRegister.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f00453fd70bb73d04c267f2f8008a4af0ca8ea6
--- /dev/null
+++ b/src/nasm/NasmRegister.java
@@ -0,0 +1,57 @@
+package nasm;
+import java.util.ArrayList;
+
+public class NasmRegister extends NasmOperand implements NasmExp{
+    public int val;
+    public int color = Nasm.REG_UNK;
+
+    public NasmRegister(int val){
+	this.val = val;
+    }
+
+    public void colorRegister(int color){
+	this.color = color;
+    }
+
+    public String toString(){
+	if(this.color == Nasm.REG_ESP) return "esp";
+	if(this.color == Nasm.REG_EBP) return "ebp";
+	if(this.color == Nasm.REG_EAX) return "eax";
+	if(this.color == Nasm.REG_EBX) return "ebx";
+	if(this.color == Nasm.REG_ECX) return "ecx";
+	if(this.color == Nasm.REG_EDX) return "edx";
+	else
+	    return "@" + this.val;
+    }
+
+    public boolean isEbp(){
+	if(this.color == Nasm.REG_EBP) return true;
+	return false;
+    }
+    
+    public boolean isGeneralRegister(){
+	if(this.color == Nasm.REG_EAX) return true;
+	if(this.color == Nasm.REG_EBX) return true;
+	if(this.color == Nasm.REG_ECX) return true;
+	if(this.color == Nasm.REG_EDX) return true;
+	if(this.color == Nasm.REG_UNK) return true;
+	return false;
+    }
+    
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public ArrayList<NasmRegister> getRegisters()
+    {
+	ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>();
+	this.getRegisters(registerList);
+	return registerList;
+    }
+    public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList)
+    {
+	registerList.add(this);
+	return registerList;
+    }
+
+}
diff --git a/src/nasm/NasmResb.java b/src/nasm/NasmResb.java
new file mode 100644
index 0000000000000000000000000000000000000000..c58418c44532bd7b125b2ed6d6a0c65b3429a659
--- /dev/null
+++ b/src/nasm/NasmResb.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmResb extends NasmPseudoInst {
+    
+    public NasmResb(NasmLabel label, int nb, String comment){
+	this.label = label;
+	this.nb = nb;
+	this.sizeInBytes = 1;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "resb", this.nb, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmResd.java b/src/nasm/NasmResd.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b4e73f1c15e6851fb766e7030be484adb99442f
--- /dev/null
+++ b/src/nasm/NasmResd.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmResd extends NasmPseudoInst {
+    
+    public NasmResd(NasmLabel label, int nb, String comment){
+	this.label = label;
+	this.nb = nb;
+	this.sizeInBytes = 4;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "resd", this.nb, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmResq.java b/src/nasm/NasmResq.java
new file mode 100644
index 0000000000000000000000000000000000000000..671bbfa6ff63c35f695ba01a9324fd627e2a853c
--- /dev/null
+++ b/src/nasm/NasmResq.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmResq extends NasmPseudoInst {
+    
+    public NasmResq(NasmLabel label, int nb, String comment){
+	this.label = label;
+	this.nb = nb;
+	this.sizeInBytes = 8;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "resq", this.nb, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmRest.java b/src/nasm/NasmRest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b1c2c05092eb8da6d428878487423b5374f9f46
--- /dev/null
+++ b/src/nasm/NasmRest.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmRest extends NasmPseudoInst {
+    
+    public NasmRest(NasmLabel label, int nb, String comment){
+	this.label = label;
+	this.nb = nb;
+	this.sizeInBytes = 10;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "rest", this.nb, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmResw.java b/src/nasm/NasmResw.java
new file mode 100644
index 0000000000000000000000000000000000000000..47bedc935aa2eeaa1a696b93351d6d62136a55ec
--- /dev/null
+++ b/src/nasm/NasmResw.java
@@ -0,0 +1,21 @@
+package nasm;
+
+public class NasmResw extends NasmPseudoInst {
+    
+    public NasmResw(NasmLabel label, int nb, String comment){
+	this.label = label;
+	this.nb = nb;
+	this.sizeInBytes = 2;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "resw", this.nb, this.comment);
+    }
+
+
+}
diff --git a/src/nasm/NasmRet.java b/src/nasm/NasmRet.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c95b985a7f66eb62790dff12f8af1455a87355a
--- /dev/null
+++ b/src/nasm/NasmRet.java
@@ -0,0 +1,18 @@
+package nasm;
+
+public class NasmRet extends NasmInst {
+    
+    public NasmRet(NasmOperand label, String comment){
+	this.label = label;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+	return super.formatInst(this.label, "ret", null, null, this.comment);
+    }
+
+}
diff --git a/src/nasm/NasmSize.java b/src/nasm/NasmSize.java
new file mode 100644
index 0000000000000000000000000000000000000000..3812007288c01ccb8ab2269b668ba9f5f5b80684
--- /dev/null
+++ b/src/nasm/NasmSize.java
@@ -0,0 +1,20 @@
+package nasm;
+
+public enum NasmSize {
+
+    BYTE(1, "byte"),
+    WORD(2, "word"),
+    DWORD(4, "dword"),
+    UNDEFINED(0, "");
+    private final String name;
+    private final int value;
+
+    NasmSize(int value, String name) {
+        this.value = value;
+        this.name = name;
+    }
+
+    public String toString(){return name;}
+    public String getName(){return this.name;}
+    public int getValue(){return value;}
+}
\ No newline at end of file
diff --git a/src/nasm/NasmSub.java b/src/nasm/NasmSub.java
new file mode 100644
index 0000000000000000000000000000000000000000..516271828d69e43a0808e9e4d85410b7126d8fc0
--- /dev/null
+++ b/src/nasm/NasmSub.java
@@ -0,0 +1,22 @@
+package nasm;
+
+public class NasmSub extends NasmInst {
+    
+    public NasmSub(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+        
+    public String toString(){
+	return super.formatInst(this.label, "sub", this.destination, this.source, this.comment);
+    }
+}
diff --git a/src/nasm/NasmVisitor.java b/src/nasm/NasmVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..091f20e9470b925f46df3510421f5bdc643c595a
--- /dev/null
+++ b/src/nasm/NasmVisitor.java
@@ -0,0 +1,47 @@
+package nasm;
+
+public interface NasmVisitor <T> {
+    public T visit(NasmAdd inst);
+    public T visit(NasmCall inst);
+    public T visit(NasmDiv inst);
+    public T visit(NasmJe inst);
+    public T visit(NasmJle inst);
+    public T visit(NasmJne inst);
+    public T visit(NasmMul inst);
+    public T visit(NasmOr inst);
+    public T visit(NasmCmp inst);
+    public T visit(NasmInst inst);
+    public T visit(NasmJge inst);
+    public T visit(NasmJl inst);
+    public T visit(NasmNot inst);
+    public T visit(NasmPop inst);
+    public T visit(NasmRet inst);
+    public T visit(NasmXor inst);
+    public T visit(NasmAnd inst);
+    public T visit(NasmJg inst);
+    public T visit(NasmJmp inst);
+    public T visit(NasmMov inst);
+    public T visit(NasmPush inst);
+    public T visit(NasmSub inst);
+    public T visit(NasmEmpty inst);
+    public T visit(NasmInt inst);
+
+    public T visit(NasmAddress operand);
+    public T visit(NasmConstant operand);
+    public T visit(NasmLabel operand);
+    public T visit(NasmRegister operand);
+
+    public T visit(NasmResb pseudoInst);
+    public T visit(NasmResw pseudoInst);
+    public T visit(NasmResd pseudoInst);
+    public T visit(NasmResq pseudoInst);
+    public T visit(NasmRest pseudoInst);
+
+    public T visit(NasmExp exp);
+    public T visit(NasmExpPlus exp);
+    public T visit(NasmExpMinus exp);
+    public T visit(NasmExpTimes exp);
+
+}
+	
+
diff --git a/src/nasm/NasmXor.java b/src/nasm/NasmXor.java
new file mode 100644
index 0000000000000000000000000000000000000000..28a0803173c338057aed831728cc0603ce1bb796
--- /dev/null
+++ b/src/nasm/NasmXor.java
@@ -0,0 +1,24 @@
+package nasm;
+
+public class NasmXor extends NasmInst {
+    
+    public NasmXor(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){
+	destUse = true;
+	destDef = true;
+	srcUse = true;
+	this.label = label;
+	this.destination = destination;
+	this.source = source;
+	this.comment = comment;
+    }
+
+    public <T> T accept(NasmVisitor <T> visitor) {
+        return visitor.visit(this);
+    }
+    
+    public String toString(){
+	return super.formatInst(this.label, "xor", this.destination, this.source, this.comment);
+    }
+
+
+}
diff --git a/src/sa.cfg b/src/sa.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..60ff9b85148f3e6fe9b397212b275494b2853a94
--- /dev/null
+++ b/src/sa.cfg
@@ -0,0 +1,127 @@
+Package saParser;
+
+Helpers
+
+lettre = [['a' .. 'z'] + ['A' .. 'Z']];
+chiffre = ['0' .. '9'];
+alpha = [lettre + ['_' + '$']];
+alphanum = [lettre + chiffre];
+
+Tokens
+
+espaces = (' ' | 13 | 10 | 9)+;
+commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13);
+
+
+po             = '(';
+pf             = ')';
+saappel        = 'SaAppel';
+sadecfonc      = 'SaDecFonc';
+sadectab       = 'SaDecTab';
+sadecvar       = 'SaDecVar';
+sadecvarsimple = 'SaDecVarSimple';
+saexpadd       = 'SaExpAdd';
+saexpand       = 'SaExpAnd';
+saexpappel     = 'SaExpAppel';
+saexpdiv       = 'SaExpDiv';
+saexpequal     = 'SaExpEqual';
+saexpfaux      = 'SaExpFaux';
+saexpinf       = 'SaExpInf';
+saexpint = 'SaExpInt';
+saexplire = 'SaExpLire';
+saexpmult = 'SaExpMult';
+saexpnot = 'SaExpNot';
+saexpor = 'SaExpOr';
+saexpsub = 'SaExpSub';
+saexpvar = 'SaExpVar';
+saexpvrai = 'SaExpVrai';
+sainstaffect = 'SaInstAffect';
+sainstbloc = 'SaInstBloc';
+sainstecriture = 'SaInstEcriture';
+sainstretour = 'SaInstRetour';
+sainstsi = 'SaInstSi';
+sainsttantque = 'SaInstTantQue';
+saldecfonc = 'SaLDecFonc';
+saldecvar = 'SaLDecVar';
+salexp = 'SaLExp';
+salinst = 'SaLInst';
+saprog = 'SaProg';
+savarindicee = 'SaVarIndicee';
+savarsimple = 'SaVarSimple';
+faux = 'faux';
+vrai = 'vrai';
+lire = 'lire';
+null = 'null';
+entier = 'entier';
+bool = 'bool';
+nul = 'nul';
+integer  = chiffre+;
+id    = alpha alphanum*;
+
+Ignored Tokens
+
+espaces, commentaire;
+
+Productions
+
+prog =         po saprog ldecvar ldecfonc pf;
+
+
+exp = {add}       po saexpadd   [op1]:exp [op2]:exp pf
+    | {and}       po saexpand   [op1]:exp [op2]:exp pf
+    | {div}       po saexpdiv   [op1]:exp [op2]:exp pf
+    | {equal}     po saexpequal [op1]:exp [op2]:exp pf
+    | {inf}       po saexpinf   [op1]:exp [op2]:exp pf
+    | {mult}      po saexpmult  [op1]:exp [op2]:exp pf
+    | {or}        po saexpor    [op1]:exp [op2]:exp pf
+    | {sub}       po saexpsub   [op1]:exp [op2]:exp pf
+    | {not}       po saexpnot         exp pf
+    | {appel}     po saexpappel appel pf
+    | {var}       po saexpvar var pf
+    | {faux}      faux
+    | {vrai}      vrai
+    | {int}       integer
+    | {lire}      lire
+    ;
+
+inst = {affect}   po sainstaffect   var exp pf
+     | {bloc}     po sainstbloc     linst pf
+     | {ecriture} po sainstecriture exp pf
+     | {retour}   po sainstretour   exp pf
+     | {si}       po sainstsi       exp [alors]:inst [sinon]:inst pf
+     | {si2}      po sainstsi       exp [alors]:inst null pf
+     | {tantque}  po sainsttantque  exp inst pf
+     | {appel}    appel
+     ;
+
+ldecfonc = {rec} po saldecfonc decfonc ldecfonc pf
+         | {fin} null
+	 ;
+
+ldecvar = {rec} po saldecvar decvar ldecvar pf
+        | {fin} null
+	;
+	
+lexp = {rec} po salexp exp lexp pf
+     | {fin} null
+     ;
+     
+linst = {rec} po salinst inst linst pf
+      | {fin} null
+      ;
+
+decfonc =      po sadecfonc id type [param]:ldecvar [variables]:ldecvar inst pf;
+
+decvar =  {tab}    po sadectab id type integer pf
+       |  {simple} po sadecvarsimple id type pf
+       ;
+
+var = {indicee} po savarindicee id exp pf
+    | {simple} po savarsimple id pf;
+
+appel = po saappel id lexp pf;
+
+type = {entier} entier
+     | {bool} bool
+     | {null} nul
+     ;
\ No newline at end of file
diff --git a/src/sa/ErrorException.java b/src/sa/ErrorException.java
new file mode 100644
index 0000000000000000000000000000000000000000..61963e600be7dc9fd5d631e3eae7f6a34990f16d
--- /dev/null
+++ b/src/sa/ErrorException.java
@@ -0,0 +1,23 @@
+package sa;
+import util.Error;
+
+public class ErrorException extends Exception{
+    private Error error;
+    private String message;
+
+
+    public ErrorException(Error error, String message){
+	this.error = error;
+	this.message = message;
+    }
+
+    public String getMessage(){
+	return message;
+    }
+
+    public int getCode(){
+	return error.code();
+    }
+
+    
+}
diff --git a/src/sa/LoadSa.java b/src/sa/LoadSa.java
new file mode 100644
index 0000000000000000000000000000000000000000..209de9c85c26193b813e1b9c8c4cdc4c544cf142
--- /dev/null
+++ b/src/sa/LoadSa.java
@@ -0,0 +1,547 @@
+package sa;
+import saParser.analysis.DepthFirstAdapter;
+import saParser.lexer.Lexer;
+import saParser.lexer.LexerException;
+import saParser.node.*;
+import saParser.parser.Parser;
+import saParser.parser.ParserException;
+import util.Error;
+import util.Type;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PushbackReader;
+
+public class LoadSa extends DepthFirstAdapter {
+    private SaProg root;
+    private SaNode returnValue;
+    private Type returnType;
+
+    public LoadSa(String saFileName) {
+        PushbackReader fileReader = null;
+        Parser parser = null;
+        Start root = null;
+        try {
+            fileReader = new PushbackReader(new FileReader(saFileName));
+        } catch (IOException e) {
+            System.err.println("cannot open input file");
+            e.printStackTrace();
+        }
+        try {
+            parser = new Parser(new Lexer(fileReader));
+            root = parser.parse();
+        } catch (ParserException e) {
+            System.err.println("syntax error");
+            e.printStackTrace();
+            System.exit(Error.SYNT.code());
+        } catch (LexerException e) {
+            System.err.println("lexical error");
+            e.printStackTrace();
+            System.exit(Error.LEX.code());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        root.apply(this);
+    }
+
+    public void defaultIn(Node node)
+    {
+        //System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(Node node)
+    {
+        //System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+    public SaProg getRoot(){return root;}
+
+
+
+
+    
+// prog =         po saprog ldecvar ldecfonc pf
+    @Override
+    public void caseAProg(AProg node)
+    {
+        inAProg(node);
+	SaLDecVar ldecVar = null;
+	SaLDecFonc ldecFonc = null;
+        if(node.getLdecvar() != null)
+        {
+            node.getLdecvar().apply(this);
+	    ldecVar = (SaLDecVar) returnValue;
+        }
+        if(node.getLdecfonc() != null)
+        {
+            node.getLdecfonc().apply(this);
+	    ldecFonc  = (SaLDecFonc) returnValue;
+        }
+	root = new SaProg(ldecVar, ldecFonc);
+        outAProg(node);
+    }
+
+// exp = {add}       po saexpadd   [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAAddExp(AAddExp node)
+    {
+        inAAddExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpAdd(op1,op2);
+        outAAddExp(node);
+    }
+
+// exp = {and}       po saexpand   [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAAndExp(AAndExp node)
+    {
+        inAAndExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpAnd(op1,op2);
+        outAAndExp(node);
+    }
+
+// exp = {div}       po saexpdiv   [op1]:exp [op2]:exp pf
+    @Override
+    public void caseADivExp(ADivExp node)
+    {
+        inADivExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpDiv(op1,op2);
+        outADivExp(node);
+    }
+
+// exp = {equal}     po saexpequal [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAEqualExp(AEqualExp node)
+    {
+        inAEqualExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpEqual(op1,op2);
+        outAEqualExp(node);
+    }
+
+// exp = {inf}       po saexpinf   [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAInfExp(AInfExp node)
+    {
+        inAInfExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpInf(op1,op2);
+        outAInfExp(node);
+    }
+
+// exp = {mult}      po saexpmult  [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAMultExp(AMultExp node)
+    {
+        inAMultExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpMult(op1,op2);
+        outAMultExp(node);
+    }
+
+// exp = {or}        po saexpor    [op1]:exp [op2]:exp pf
+    @Override
+    public void caseAOrExp(AOrExp node)
+    {
+        inAOrExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpOr(op1,op2);
+    }
+
+// exp = {sub}       po saexpsub   [op1]:exp [op2]:exp pf
+    @Override
+    public void caseASubExp(ASubExp node)
+    {
+        inASubExp(node);
+	node.getOp1().apply(this);
+	SaExp op1 = (SaExp) returnValue;
+	node.getOp2().apply(this);
+	SaExp op2 = (SaExp) returnValue;
+	returnValue = new SaExpSub(op1,op2);
+        outASubExp(node);
+    }
+
+// exp = {not}       po saexpnot         exp pf
+    @Override
+    public void caseANotExp(ANotExp node)
+    {
+        inANotExp(node);
+	node.getExp().apply(this);
+	SaExp exp = (SaExp) returnValue;
+	returnValue = new SaExpNot(exp);
+        outANotExp(node);
+    }
+
+// exp = {appel}     po saexpappel appel pf
+    @Override
+    public void caseAAppelExp(AAppelExp node)
+    {
+        inAAppelExp(node);
+	node.getAppel().apply(this);
+	SaAppel appel = (SaAppel) returnValue;
+	returnValue = new SaExpAppel(appel);
+        outAAppelExp(node);
+    }
+
+// exp = {var}       po saexpvar var pf
+    @Override
+    public void caseAVarExp(AVarExp node)
+    {
+        inAVarExp(node);
+	node.getVar().apply(this);
+	SaVar var = (SaVar) returnValue;
+	returnValue = new SaExpVar(var);
+        outAVarExp(node);
+    }
+
+// exp = {faux}      faux
+    @Override
+    public void caseAFauxExp(AFauxExp node)
+    {
+        inAFauxExp(node);
+	returnValue = new SaExpFaux();
+        outAFauxExp(node);
+    }
+
+// exp = {vrai}      vrai
+    @Override
+    public void caseAVraiExp(AVraiExp node)
+    {
+        inAVraiExp(node);
+	returnValue = new SaExpVrai();
+        outAVraiExp(node);
+    }
+
+// exp = {int}       integer
+    @Override
+    public void caseAIntExp(AIntExp node)
+    {
+        inAIntExp(node);
+	int value = Integer.parseInt(node.getInteger().getText());
+	returnValue = new SaExpInt(value);
+        outAIntExp(node);
+    }
+
+// exp = {lire}      lire
+    @Override
+    public void caseALireExp(ALireExp node)
+    {
+        inALireExp(node);
+	returnValue = new SaExpLire();
+        outALireExp(node);
+    }
+
+// inst = {affect}   po sainstaffect   var exp pf
+    @Override
+    public void caseAAffectInst(AAffectInst node)
+    {
+        inAAffectInst(node);
+	node.getVar().apply(this);
+	SaVar var = (SaVar) returnValue;
+	node.getExp().apply(this);
+	SaExp exp = (SaExp) returnValue;
+	returnValue = new SaInstAffect(var, exp);
+        outAAffectInst(node);
+    }
+
+// inst = {bloc}     po sainstbloc     linst pf
+    @Override
+    public void caseABlocInst(ABlocInst node)
+    {
+        inABlocInst(node);
+	node.getLinst().apply(this);
+	SaLInst linst = (SaLInst) returnValue;
+	returnValue = new SaInstBloc(linst);
+        outABlocInst(node);
+    }
+
+// inst = {ecriture} po sainstecriture exp pf
+    @Override
+    public void caseAEcritureInst(AEcritureInst node)
+    {
+        inAEcritureInst(node);
+	node.getExp().apply(this);
+	SaExp exp = (SaExp) returnValue;
+	returnValue = new SaInstEcriture(exp);
+        outAEcritureInst(node);
+    }
+
+// inst = {retour}   po sainstretour   exp pf
+    @Override
+    public void caseARetourInst(ARetourInst node)
+    {
+        inARetourInst(node);
+	node.getExp().apply(this);
+	SaExp exp = (SaExp) returnValue;
+	returnValue = new SaInstRetour(exp);
+        outARetourInst(node);
+    }
+
+// inst = {si}       po sainstsi       exp [alors]:inst [sinon]:inst pf
+    @Override
+    public void caseASiInst(ASiInst node)
+    {
+        inASiInst(node);
+	node.getExp().apply(this);
+	SaExp si = (SaExp) returnValue;
+	node.getAlors().apply(this);
+	SaInst alors = (SaInst) returnValue;
+	SaInst sinon = null;
+        if(node.getSinon() != null)
+        {
+            node.getSinon().apply(this);
+	    sinon = (SaInst) returnValue;
+        }
+	returnValue = new SaInstSi(si, alors, sinon);
+        outASiInst(node);
+    }
+
+    // inst = {si2}      po sainstsi       exp [alors]:inst null pf
+
+    @Override
+    public void caseASi2Inst(ASi2Inst node)
+    {
+        inASi2Inst(node);
+        node.getExp().apply(this);
+        SaExp si = (SaExp) returnValue;
+        node.getAlors().apply(this);
+        SaInst alors = (SaInst) returnValue;
+        returnValue = new SaInstSi(si, alors, null);
+        outASi2Inst(node);
+    }
+
+
+    // inst = {tantque}  po sainsttantque  exp inst pf
+   @Override
+    public void caseATantqueInst(ATantqueInst node)
+    {
+        inATantqueInst(node);
+	node.getExp().apply(this);
+	SaExp test = (SaExp) returnValue;
+	node.getInst().apply(this);
+	SaInst bloc = (SaInst) returnValue;
+	returnValue = new SaInstTantQue(test, bloc);
+        outATantqueInst(node);
+    }
+
+// ldecfonc = {rec} po saldecfonc decfonc ldecfonc pf
+    @Override
+    public void caseARecLdecfonc(ARecLdecfonc node)
+    {
+        inARecLdecfonc(node);
+	node.getDecfonc().apply(this);
+	SaDecFonc dec = (SaDecFonc) returnValue;
+	node.getLdecfonc().apply(this);
+	SaLDecFonc ldec = (SaLDecFonc) returnValue; 
+        returnValue = new SaLDecFonc(dec, ldec);
+        outARecLdecfonc(node);
+    }
+
+// ldecfonc = {fin} null
+    @Override
+    public void caseAFinLdecfonc(AFinLdecfonc node)
+    {
+        inAFinLdecfonc(node);
+	returnValue = null;
+        outAFinLdecfonc(node);
+    }
+
+// ldecvar = {rec} po saldecvar decvar ldecvar pf
+    @Override
+    public void caseARecLdecvar(ARecLdecvar node)
+    {
+        inARecLdecvar(node);
+	node.getDecvar().apply(this);
+	SaDecVar dec = (SaDecVar) returnValue;
+	node.getLdecvar().apply(this);
+	SaLDecVar ldec = (SaLDecVar) returnValue;
+	returnValue = new SaLDecVar(dec, ldec);
+        outARecLdecvar(node);
+    }
+
+// ldecvar = {fin} null
+    @Override
+    public void caseAFinLdecvar(AFinLdecvar node)
+    {
+        inAFinLdecvar(node);
+	returnValue = null;
+        outAFinLdecvar(node);
+    }
+
+// lexp = {rec} po salexp exp lexp pf
+    @Override
+    public void caseARecLexp(ARecLexp node)
+    {
+        inARecLexp(node);
+	node.getExp().apply(this);
+	SaExp exp = (SaExp) returnValue;
+	node.getLexp().apply(this);
+	SaLExp lexp = (SaLExp) returnValue;
+	returnValue = new SaLExp(exp, lexp);
+        outARecLexp(node);
+    }
+
+// lexp = {fin} null
+    @Override
+    public void caseAFinLexp(AFinLexp node)
+    {
+        inAFinLexp(node);
+	returnValue = null;
+        outAFinLexp(node);
+    }
+
+// linst = {rec} po salinst inst linst pf
+    @Override
+    public void caseARecLinst(ARecLinst node)
+    {
+        inARecLinst(node);
+	node.getInst().apply(this);
+	SaInst inst = (SaInst) returnValue;
+	node.getLinst().apply(this);
+	SaLInst linst = (SaLInst) returnValue;
+	returnValue = new SaLInst(inst, linst);
+        outARecLinst(node);
+    }
+
+// linst = {fin} null
+    @Override
+    public void caseAFinLinst(AFinLinst node)
+    {
+        inAFinLinst(node);
+	returnValue = null;
+        outAFinLinst(node);
+    }
+
+// decfonc =      po sadecfonc id [param]:ldecvar [variables]:ldecvar inst type pf
+    @Override
+    public void caseADecfonc(ADecfonc node)
+    {
+        inADecfonc(node);
+	String foncName = node.getId().getText();
+	node.getParam().apply(this);
+	SaLDecVar params = (SaLDecVar) returnValue;
+	node.getVariables().apply(this);
+	SaLDecVar variables = (SaLDecVar) returnValue;
+	node.getInst().apply(this);
+	SaInst corps = (SaInst) returnValue;
+	node.getType().apply(this);
+	Type type = returnType;
+	returnValue = new SaDecFonc(foncName, type, params, variables, corps);
+        outADecfonc(node);
+    }
+
+// decvar =  {tab}    po sadectab id integer type pf
+    @Override
+    public void caseATabDecvar(ATabDecvar node)
+    {
+        inATabDecvar(node);
+	String nom = node.getId().getText();
+	int taille = Integer.parseInt(node.getInteger().getText());
+	node.getType().apply(this);
+	Type type = returnType;
+	returnValue = new SaDecTab(nom, type, taille);
+        outATabDecvar(node);
+    }
+
+// decvar =  {simple} po sadecvarsimple id type pf
+    @Override
+    public void caseASimpleDecvar(ASimpleDecvar node)
+    {
+        inASimpleDecvar(node);
+	String nom = node.getId().getText();
+	node.getType().apply(this);
+	Type type = returnType;
+	returnValue = new SaDecVarSimple(nom, type);
+        outASimpleDecvar(node);
+    }
+
+    // var = {indicee} po savarindicee id exp pf
+    @Override
+    public void caseAIndiceeVar(AIndiceeVar node)
+    {
+        inAIndiceeVar(node);
+	String nom = node.getId().getText();
+	node.getExp().apply(this);
+	SaExp indice = (SaExp) returnValue;
+	returnValue = new SaVarIndicee(nom, indice);
+        outAIndiceeVar(node);
+    }
+
+    // var = {simple} po savarsimple id pf
+    @Override
+    public void caseASimpleVar(ASimpleVar node)
+    {
+        inASimpleVar(node);
+	String nom = node.getId().getText();
+	returnValue = new SaVarSimple(nom);
+        outASimpleVar(node);
+    }
+
+// appel = po saappel id lexp pf
+    @Override
+    public void caseAAppel(AAppel node)
+    {
+        inAAppel(node);
+	String nom = node.getId().getText();
+	node.getLexp().apply(this);
+	SaLExp arguments = (SaLExp) returnValue;
+	returnValue = new SaAppel(nom, arguments);
+        outAAppel(node);
+    }
+
+// type = {entier} entier
+    @Override
+    public void caseAEntierType(AEntierType node)
+    {
+        inAEntierType(node);
+	returnType = Type.ENTIER;
+        outAEntierType(node);
+    }
+
+// type = {bool} bool
+    @Override
+    public void caseABoolType(ABoolType node)
+    {
+        inABoolType(node);
+	returnType = Type.BOOL;
+        outABoolType(node);
+    }
+
+// type = {null} nul
+    @Override
+    public void caseANullType(ANullType node)
+    {
+        inANullType(node);
+	returnType = Type.NUL;
+        outANullType(node);
+    }
+}
+
+
+
+
+
+
diff --git a/src/sa/SaAppel.java b/src/sa/SaAppel.java
new file mode 100644
index 0000000000000000000000000000000000000000..84a3f776e1a22e1576cef5ae7617683f99adf327
--- /dev/null
+++ b/src/sa/SaAppel.java
@@ -0,0 +1,33 @@
+package sa;
+import ts.*;
+import util.Type;
+
+
+public class SaAppel implements SaExp, SaInst{
+    private String nom;
+    private SaLExp arguments;
+    public TsItemFct tsItem;
+
+    public SaAppel(String nom, SaLExp arguments){
+	this.nom = nom;
+	this.arguments = arguments;
+	this.tsItem = null;
+    }
+
+    public String getNom(){return this.nom;}
+    public SaLExp getArguments(){return this.arguments;}
+
+
+    public Type getType(){
+	return tsItem.typeRetour;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName()+ " " + nom + " " + arguments + ")";
+    }
+}
diff --git a/src/sa/SaCheckLinkage.java b/src/sa/SaCheckLinkage.java
new file mode 100644
index 0000000000000000000000000000000000000000..f25f01789debecd89aea3c1023b5dac5e3b70e42
--- /dev/null
+++ b/src/sa/SaCheckLinkage.java
@@ -0,0 +1,42 @@
+package sa;
+
+import util.Error;
+
+public class SaCheckLinkage extends SaDepthFirstVisitor <Void>{
+
+    public Void visit(SaDecFonc node) throws Exception {
+        defaultIn(node);
+        if (node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecFonc");
+        if(node.getParametres() != null) node.getParametres().accept(this);
+        if(node.getVariable() != null) node.getVariable().accept(this);
+        if(node.getCorps() != null) node.getCorps().accept(this);
+        defaultOut(node);
+        return null;
+
+    }
+
+    public Void visit(SaDecVarSimple node) throws ErrorException {
+        if (node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecVarSimple");
+        return null;
+    }
+
+    public Void visit(SaDecTab node) throws ErrorException {
+        if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecTab");
+        return null;
+    }
+
+    public Void visit(SaAppel node) throws ErrorException{
+        if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaAppel");
+        return null;
+    }
+
+    public Void visit(SaVarSimple node) throws ErrorException{
+        if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaVarSimple");
+        return null;
+    }
+    public Void visit(SaVarIndicee node) throws ErrorException{
+        if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaVarIndicee");
+        return null;
+    }
+}
+
diff --git a/src/sa/SaDec.java b/src/sa/SaDec.java
new file mode 100644
index 0000000000000000000000000000000000000000..275b4b6d00d097645a8e3f26fe73cf9599e5fd5a
--- /dev/null
+++ b/src/sa/SaDec.java
@@ -0,0 +1,5 @@
+package sa;
+
+public interface SaDec extends SaNode {
+    public String getNom();
+}
diff --git a/src/sa/SaDecFonc.java b/src/sa/SaDecFonc.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f4b817756c74306030039cecf3df83db5c309de
--- /dev/null
+++ b/src/sa/SaDecFonc.java
@@ -0,0 +1,34 @@
+package sa;
+import ts.*;
+import util.Type;
+
+public class SaDecFonc implements SaDec{
+    private String    nom;
+    private SaLDecVar parametres;
+    private SaLDecVar variables;
+    private SaInst    corps;
+    private Type      typeRetour;
+    public  TsItemFct tsItem;
+
+    public SaDecFonc(String nom, Type typeRetour, SaLDecVar parametres, SaLDecVar variables, SaInst corps){
+	this.nom = nom;
+	this.typeRetour = typeRetour;
+	this.parametres = parametres;
+	this.variables = variables;
+	this.corps = corps;
+	this.tsItem = null;
+    }
+
+    public String    getNom(){return this.nom;}
+    public Type      getTypeRetour(){return this.typeRetour;}
+    public SaLDecVar getParametres(){return this.parametres;}
+    public SaLDecVar getVariable(){return this.variables;}
+    public SaInst    getCorps(){return this.corps;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+    public String toString(){
+        return "(" + this.getClass().getSimpleName() + " " + nom + " " + typeRetour + " " + parametres + " " + variables + " " + corps + ")";
+    }
+}
diff --git a/src/sa/SaDecTab.java b/src/sa/SaDecTab.java
new file mode 100644
index 0000000000000000000000000000000000000000..8eaf2094c4e567fb0fa25e14eb2390c2ebe5090c
--- /dev/null
+++ b/src/sa/SaDecTab.java
@@ -0,0 +1,31 @@
+package sa;
+import ts.*;
+import util.Type;
+
+public class SaDecTab implements SaDecVar{
+    private String       nom;
+    private int          taille;
+    private Type         type;
+    public  TsItemVar    tsItem;
+
+    public SaDecTab(String nom, Type type, int taille){
+	this.nom = nom;
+	this.type = type;
+	this.taille = taille;
+	this.tsItem = null;
+    }
+
+    public String       getNom(){return this.nom;}
+    public int          getTaille(){return this.taille;}
+    public Type         getType(){return this.type;}
+    public TsItemVar    getTsItem(){return this.tsItem;}
+    public void         setTsItem(TsItemVar tsItem){this.tsItem = tsItem;}
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + nom + " " + type + " " + taille + ")";
+    }
+}
diff --git a/src/sa/SaDecVar.java b/src/sa/SaDecVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cc6f02a87b83e5a3692d4c9fbfab6533acb5386
--- /dev/null
+++ b/src/sa/SaDecVar.java
@@ -0,0 +1,11 @@
+package sa;
+import util.Type;
+import ts.*;
+
+public interface SaDecVar extends SaNode {
+    public String    getNom();
+    public Type      getType();
+    public TsItemVar getTsItem();
+    public void      setTsItem(TsItemVar tsItem);
+
+}
diff --git a/src/sa/SaDecVarSimple.java b/src/sa/SaDecVarSimple.java
new file mode 100644
index 0000000000000000000000000000000000000000..557cf28b32d934981c05104457e587a433767a00
--- /dev/null
+++ b/src/sa/SaDecVarSimple.java
@@ -0,0 +1,29 @@
+package sa;
+import ts.*;
+import util.Type;
+
+public class SaDecVarSimple implements SaDecVar{
+    private String          nom;
+    private Type            type;
+    public  TsItemVar       tsItem;
+
+    public SaDecVarSimple(String nom, Type type){
+	this.nom = nom;
+	this.type = type;
+	this.tsItem = null;
+    }
+
+    public String          getNom(){return this.nom;}
+    public Type            getType(){return this.type;}
+    public TsItemVar       getTsItem(){return this.tsItem;}
+    public void            setTsItem(TsItemVar tsItem){this.tsItem = tsItem;}
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + nom + " " + type + ")";
+    }
+}
diff --git a/src/sa/SaDepthFirstVisitor.java b/src/sa/SaDepthFirstVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..ded93ad194c4d1bc1f81c6f76a48c900262ce527
--- /dev/null
+++ b/src/sa/SaDepthFirstVisitor.java
@@ -0,0 +1,386 @@
+package sa;
+
+
+// P -> LDEC LDEC 
+
+// DEC -> var id taille 
+// DEC -> fct id LDEC LDEC LINST 
+// DEC -> var id 
+
+// LDEC -> DEC LDEC 
+// LDEC -> null 
+
+// VAR  ->simple id 
+// VAR  ->indicee id EXP
+
+// LINST -> INST LINST 
+// LINST -> null 
+
+// INST -> aff VAR EXP 
+// INST -> si EXP LINST LINST 
+// INST -> tq EXP LINST 
+// INST -> app APP 
+// INST -> ret EXP 
+// INST -> ecr EXP 
+
+// APP -> id LEXP 
+
+// LEXP -> EXP LEXP 
+// LEXP -> null 
+
+// EXP -> op2 EXP EXP 
+// EXP -> op1 EXP 
+// EXP -> VAR 
+// EXP -> entier 
+// EXP -> APP 
+// EXP -> lire
+
+
+//**********
+
+// VAR  ->simple id 
+// VAR  ->indicee id EXP
+
+// LINST -> INST LINST 
+// LINST -> null 
+
+// INST -> aff VAR EXP 
+// INST -> si EXP LINST LINST 
+// INST -> tq EXP LINST 
+// INST -> app APP 
+// INST -> ecr EXP 
+
+// APP -> id LEXP 
+
+// LEXP -> EXP LEXP 
+// LEXP -> null 
+
+
+// EXP -> op1 EXP 
+// EXP -> VAR 
+
+// EXP -> lire
+
+
+public class SaDepthFirstVisitor <T> implements SaVisitor <T>{
+    
+    //   private NouvelleClasse x;
+    public void defaultIn(SaNode node)
+    {
+    }
+
+    public void defaultOut(SaNode node)
+    {
+    }
+
+    // P -> LDEC LDEC 
+    public T visit(SaProg node) throws Exception
+    {
+	defaultIn(node);
+	if(node.getVariables() != null)
+	    node.getVariables().accept(this);
+	if(node.getFonctions() != null)
+	    node.getFonctions().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    // DEC -> var id taille 
+    public T visit(SaDecTab node) throws Exception{
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaExp node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    // EXP -> entier
+    public T visit(SaExpInt node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    // EXP -> vrai
+    public T visit(SaExpVrai node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    // EXP -> faux
+    public T visit(SaExpFaux node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaExpVar node) throws Exception
+    {
+	defaultIn(node);
+	node.getVar().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaInstEcriture node) throws Exception
+    {
+	defaultIn(node);
+	node.getArg().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaInstTantQue node) throws Exception
+    {
+	defaultIn(node);
+	node.getTest().accept(this);
+	if (node.getFaire() != null)
+  	node.getFaire().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    public T visit(SaLInst node) throws Exception
+    {
+	defaultIn(node);
+	if(node != null){
+	    if(node.getTete() != null)node.getTete().accept(this);
+	    if(node.getQueue() != null) node.getQueue().accept(this);
+	}
+	defaultOut(node);
+	return null;
+    }
+
+    // DEC -> fct id LDEC LDEC LINST 
+    public T visit(SaDecFonc node) throws Exception
+    {
+	defaultIn(node);
+	if(node.getParametres() != null) node.getParametres().accept(this);
+	if(node.getVariable() != null) node.getVariable().accept(this);
+	if(node.getCorps() != null) node.getCorps().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    // DEC -> var id 
+    public T visit(SaDecVar node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaInstAffect node) throws Exception
+    {
+	defaultIn(node);
+	node.getLhs().accept(this);
+	node.getRhs().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    // LDEC -> DEC LDEC 
+    // LDEC -> null 
+    /*    public T visit(SaLDec node) throws Exception
+    {
+	defaultIn(node);
+	node.getTete().accept(this);
+	if(node.getQueue() != null) node.getQueue().accept(this);
+	defaultOut(node);
+	return null;
+	}*/
+    
+    public T visit(SaLDecVar node) throws Exception
+    {
+	defaultIn(node);
+	node.getTete().accept(this);
+	if(node.getQueue() != null) node.getQueue().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaLDecFonc node) throws Exception
+    {
+	defaultIn(node);
+	node.getTete().accept(this);
+	if(node.getQueue() != null) node.getQueue().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaVarSimple node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaAppel node) throws Exception
+    {
+	defaultIn(node);
+	if(node.getArguments() != null) node.getArguments().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaExpAppel node) throws Exception
+    {
+	defaultIn(node);
+	node.getVal().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> add EXP EXP
+    public T visit(SaExpAdd node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> sub EXP EXP
+    public T visit(SaExpSub node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> mult EXP EXP
+    public T visit(SaExpMult node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> div EXP EXP
+    public T visit(SaExpDiv node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    // EXP -> inf EXP EXP
+    public T visit(SaExpInf node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> eq EXP EXP
+    public T visit(SaExpEqual node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> and EXP EXP
+    public T visit(SaExpAnd node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+
+    // EXP -> or EXP EXP
+    public T visit(SaExpOr node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	node.getOp2().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    // EXP -> not EXP
+    public T visit(SaExpNot node) throws Exception
+    {
+	defaultIn(node);
+	node.getOp1().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+
+    public T visit(SaExpLire node) throws Exception
+    {
+	defaultIn(node);
+	defaultOut(node);
+	return null;
+    }
+
+    public T visit(SaInstBloc node) throws Exception
+    {
+	defaultIn(node);
+	node.getVal().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+    public T visit(SaInstSi node) throws Exception
+    {
+	defaultIn(node);
+	node.getTest().accept(this);
+	if (node.getAlors() != null)
+  	node.getAlors().accept(this);
+	if(node.getSinon() != null) node.getSinon().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+// INST -> ret EXP 
+    public T visit(SaInstRetour node) throws Exception
+    {
+	defaultIn(node);
+	node.getVal().accept(this);
+	defaultOut(node);
+	return null;
+    }
+
+    
+    public T visit(SaLExp node) throws Exception
+    {
+	defaultIn(node);
+	node.getTete().accept(this);
+	if(node.getQueue() != null)
+	    node.getQueue().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    public T visit(SaVarIndicee node) throws Exception
+    {
+	defaultIn(node);
+	node.getIndice().accept(this);
+	defaultOut(node);
+	return null;
+    }
+    
+}
diff --git a/src/sa/SaEnvironment.java b/src/sa/SaEnvironment.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c85759e6227e50911e0e656b6835235672e5483
--- /dev/null
+++ b/src/sa/SaEnvironment.java
@@ -0,0 +1,33 @@
+package sa;
+import java.util.*;
+import ts.*;
+import util.Memory;
+
+public class SaEnvironment {
+    public Memory vars;
+    public Memory args;
+    public TypeVal returnValue;
+
+    public SaEnvironment (TsItemFct fct)
+    {
+	SaLExp lArgs = null;
+	Ts localTable = fct.getTable();
+	int i = 0;
+
+	args = new Memory(localTable.getAdrArgCourante(), 0);
+	vars = new Memory(localTable.getAdrVarCourante(), 0);
+
+	//	args = new Memory(200, 0);
+	//	vars = new Memory(200, 0);
+
+	returnValue = null;
+	//	System.out.println("allocation d'un nouvel environnement, fonction " + fct.getIdentif());
+	//	System.out.println("dim var = " + localTable.getAdrVarCourante());
+	//	System.out.println("dim arg = " + localTable.getAdrArgCourante());
+	
+    }
+
+
+    public TypeVal getReturnValue(){return returnValue;}
+    public void setReturnValue(TypeVal typeVal){returnValue = typeVal;}
+}
diff --git a/src/sa/SaEval.java b/src/sa/SaEval.java
new file mode 100644
index 0000000000000000000000000000000000000000..b66416e63337fe2c5c90868ac124bb2ea9b0097a
--- /dev/null
+++ b/src/sa/SaEval.java
@@ -0,0 +1,465 @@
+package sa;
+import java.util.*;
+import java.io.*;
+import ts.*;
+import util.Memory;
+import util.Type;
+
+
+public class SaEval extends SaDepthFirstVisitor <TypeVal> {
+    private Ts tableGlobale;
+    private SaEnvironment curEnv;
+    private Memory varGlob;
+    private ArrayList<String> programOutput = new ArrayList<String>();
+    private boolean stop;
+
+	public SaEval(SaNode root, Ts tableGlobale){
+		this.tableGlobale = tableGlobale;
+		curEnv = null;
+		varGlob = new Memory(tableGlobale.getAdrVarCourante(), 0);
+		stop = false;
+		SaAppel appelMain = new SaAppel("main", null);
+		appelMain.tsItem = tableGlobale.getFct("main");
+
+		try{
+			appelMain.accept(this);
+		} catch(Exception e){}
+	}
+
+	public TypeVal getVar(SaVarSimple saVar){
+		TsItemVarSimple tsItem = saVar.getTsItem();
+		return getVar(tsItem);
+    }
+    
+    public TypeVal getVar(TsItemVarSimple tsItem){
+		Memory container = null;
+		if(tsItem.portee == this.tableGlobale) // variable globale
+			container = varGlob;
+		else
+			container = (tsItem.isParam)? curEnv.args : curEnv.vars;
+		if(tsItem.type == Type.ENTIER)
+			return new TypeVal(container.readInt(tsItem.adresse));
+		//	    if(tsItem.type == Type.BOOL)
+		return new TypeVal(container.readBoolean(tsItem.adresse));
+    }
+
+    public void setVar(SaVarSimple saVar, TypeVal typeVal){
+		TsItemVarSimple tsItem = saVar.getTsItem();
+		setVar(tsItem, typeVal);
+    }
+
+
+	public void setVar(TsItemVarSimple tsItem, TypeVal typeVal){
+		Memory container = null;
+		// trois cas possibles : une variable locale, une variable globale ou un argument
+		if(tsItem.portee == this.tableGlobale) // variable globale
+			container = varGlob;
+		else if (tsItem.isParam)
+			container = curEnv.args;
+		else
+			container = curEnv.vars;
+
+		if(tsItem.type == Type.ENTIER)
+			container.writeInt(tsItem.adresse, typeVal.valInt);
+		if(tsItem.type == Type.BOOL)
+			container.writeBoolean(tsItem.adresse, typeVal.valBool);
+    }
+    
+    private TypeVal getVarGlobIndicee(SaVarIndicee saVarIndicee, TypeVal indice){
+		TsItemVar tsItem = saVarIndicee.getTsItem();
+		if(tsItem.type == Type.ENTIER)
+			return new TypeVal(varGlob.readInt(tsItem.adresse + tsItem.type.taille() * indice.valInt));
+		//	if(tsItem.type == Type.BOOL)
+		return new TypeVal(varGlob.readBoolean(tsItem.adresse + tsItem.type.taille() * indice.valInt));
+    }
+
+	private void setVarGlobIndicee(SaVarIndicee saVarIndicee, TypeVal indice, TypeVal typeVal){
+		TsItemVar tsItem = saVarIndicee.getTsItem();
+		if(tsItem.type == Type.ENTIER)
+			varGlob.writeInt(tsItem.adresse + tsItem.type.taille() * indice.valInt, typeVal.valInt);
+		if(tsItem.type == Type.BOOL)
+			varGlob.writeBoolean(tsItem.adresse + tsItem.type.taille() * indice.valInt , typeVal.valBool);
+    }
+
+
+	public void affiche(String baseFileName){
+		String fileName;
+		PrintStream out = System.out;
+
+		if (baseFileName != null){
+			try {
+				baseFileName = baseFileName;
+				fileName = baseFileName + ".saout";
+				out = new PrintStream(fileName);
+			} catch (IOException e) {
+				System.err.println("Error: " + e.getMessage());
+			}
+		}
+		for (String line : programOutput)
+			out.println(line);
+    }
+
+
+    
+    public void defaultIn(SaNode node)
+    {
+    }
+
+    public void defaultOut(SaNode node)
+    {
+    }
+
+    // P -> LDEC LDEC 
+    public TypeVal visit(SaProg node) throws Exception
+    {
+		defaultIn(node);
+		System.out.println("dans prog");
+		if(node.getVariables() != null)
+			node.getVariables().accept(this);
+		if(node.getFonctions() != null)
+			node.getFonctions().accept(this);
+		defaultOut(node);
+		return null;
+    }
+    
+    // DEC -> var id taille 
+    public TypeVal visit(SaDecTab node) throws Exception{
+		defaultIn(node);
+		defaultOut(node);
+		return null;
+    }
+    
+    public TypeVal visit(SaExp node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return null;
+    }
+    
+    // EXP -> entier
+    public TypeVal visit(SaExpInt node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return new TypeVal(node.getVal());
+    }
+
+
+    // EXP -> vrai
+    public TypeVal visit(SaExpVrai node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return new TypeVal(true);
+    }
+    
+    // EXP -> faux
+    public TypeVal visit(SaExpFaux node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return new TypeVal(false);
+    }
+        
+    public TypeVal visit(SaExpVar node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal typeVal = node.getVar().accept(this);
+		defaultOut(node);
+		return typeVal;
+    }
+    
+    public TypeVal visit(SaInstEcriture node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal arg = node.getArg().accept(this);
+		if(arg.type == Type.ENTIER)
+			programOutput.add(String.valueOf(arg.valInt));
+		else if(arg.type == Type.BOOL){
+			if(arg.valBool == true)
+				programOutput.add(String.valueOf(1));
+			else
+				programOutput.add(String.valueOf(0));
+		}
+		defaultOut(node);
+		return null;
+    }
+    
+    public TypeVal visit(SaInstTantQue node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal test = node.getTest().accept(this);
+		while (test.valBool == true){
+			if (node.getFaire() != null)
+				node.getFaire().accept(this);
+			else{
+				System.out.println("Infinite loop detected, breaking out");
+				break;
+			}
+			test = node.getTest().accept(this);
+		}
+		defaultOut(node);
+		return null;
+    }
+    
+    public TypeVal visit(SaLInst node) throws Exception
+    {
+		defaultIn(node);
+		stop = false;
+		TypeVal valRet = node.getTete().accept(this);
+		if(!stop && node.getQueue() != null) node.getQueue().accept(this);
+		defaultOut(node);
+		return null;
+    }
+
+    // DEC -> fct id LDEC LDEC LINST 
+    public TypeVal visit(SaDecFonc node) throws Exception
+    {
+		defaultIn(node);
+		if(node.getParametres() != null) node.getParametres().accept(this);
+		if(node.getVariable() != null) node.getVariable().accept(this);
+		node.getCorps().accept(this);
+		defaultOut(node);
+		return null;
+    }
+    
+    // DEC -> var id 
+    public TypeVal visit(SaDecVar node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return null;
+    }
+    
+    public TypeVal visit(SaInstAffect node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal typeVal = node.getRhs().accept(this);
+		if(node.getLhs() instanceof SaVarIndicee){ // c'est une case de tableau, donc forcément globale
+			SaVarIndicee lhsIndicee = (SaVarIndicee) node.getLhs();
+			TypeVal indice = lhsIndicee.getIndice().accept(this);
+			setVarGlobIndicee(lhsIndicee, indice, typeVal);
+		} else{
+			setVar((SaVarSimple) node.getLhs(), typeVal);
+		}
+
+		defaultOut(node);
+		return null;
+    }
+    
+    // LDEC -> DEC LDEC 
+    // LDEC -> null 
+    /*    public TypeVal visit(SaLDec node) throws Exception
+    {
+	defaultIn(node);
+	node.getTete().accept(this);
+	if(node.getQueue() != null) node.getQueue().accept(this);
+	defaultOut(node);
+	return null;
+	}*/
+    
+    public TypeVal visit(SaVarSimple node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal typeVal = getVar(node);
+		defaultOut(node);
+		return typeVal;
+    }
+    
+    public TypeVal visit(SaAppel node) throws Exception
+    {
+		defaultIn(node);
+		TsItemFct fct = node.tsItem;
+		SaLExp lArgs = null;
+		SaLDecVar lParam = null;
+		Ts localTable = fct.getTable();
+		// on construit la liste des arguments d'appel de la fonction
+		ArrayList<TypeVal> listeArguments = new ArrayList<TypeVal>();
+		for(lArgs = node.getArguments(); lArgs != null; lArgs = lArgs.getQueue()){
+			listeArguments.add(lArgs.getTete().accept(this));
+		}
+
+		//on sauvegarde de l'environnement courant pour le restaurer après l'appel
+		SaEnvironment oldEnv = curEnv;
+		// on crée un nouvel environnement pour la fonction appelée
+		// le nouvel environnement est l'environnement courant
+		curEnv = new SaEnvironment(fct);
+
+		// on stocke les valeurs des arguments dans l'environnement
+		int n = 0;
+		for(lParam = fct.saDecFonc.getParametres(); lParam != null; lParam = lParam.getQueue()){
+			setVar((TsItemVarSimple)((SaDecVar)lParam.getTete()).getTsItem(), listeArguments.get(n));
+			n++;
+		}
+		// on exécute le corps de la fonction
+		if(fct.saDecFonc.getCorps() != null)
+			fct.saDecFonc.getCorps().accept(this);
+
+		// on récupère la valeur de retour
+		TypeVal returnValue = curEnv.getReturnValue();
+
+		//restauration de l'environnement d'avant appel
+		curEnv = oldEnv;
+		defaultOut(node);
+		return returnValue;
+    }
+    
+    public TypeVal visit(SaExpAppel node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal typeVal = node.getVal().accept(this);
+		defaultOut(node);
+		return typeVal;
+    }
+
+    // EXP -> add EXP EXP
+    public TypeVal visit(SaExpAdd node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal(op1.valInt + op2.valInt);
+    }
+
+    // EXP -> sub EXP EXP
+    public TypeVal visit(SaExpSub node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal(op1.valInt - op2.valInt);
+    }
+
+    // EXP -> mult EXP EXP
+    public TypeVal visit(SaExpMult node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal(op1.valInt * op2.valInt);
+    }
+
+    // EXP -> div EXP EXP
+    public TypeVal visit(SaExpDiv node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal((int) op1.valInt / op2.valInt);
+    }
+    
+    // EXP -> inf EXP EXP
+    public TypeVal visit(SaExpInf node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal((op1.valInt < op2.valInt)? true : false);
+    }
+
+    // EXP -> eq EXP EXP
+    public TypeVal visit(SaExpEqual node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		if(op1.type == Type.ENTIER)
+			return new TypeVal((op1.valInt == op2.valInt)? true : false);
+		else
+			return new TypeVal((op1.valBool == op2.valBool)? true : false);
+    }
+
+    // EXP -> and EXP EXP
+    public TypeVal visit(SaExpAnd node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal(op1.valBool && op2.valBool);
+    }
+    
+    // EXP -> or EXP EXP
+    public TypeVal visit(SaExpOr node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		TypeVal op2 = node.getOp2().accept(this);
+		defaultOut(node);
+		return new TypeVal(op1.valBool || op2.valBool);
+    }
+
+    // EXP -> not EXP
+    public TypeVal visit(SaExpNot node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal op1 = node.getOp1().accept(this);
+		defaultOut(node);
+		return new TypeVal(!op1.valBool);
+    }
+
+
+    public TypeVal visit(SaExpLire node) throws Exception
+    {
+		defaultIn(node);
+		defaultOut(node);
+		return null;
+    }
+
+    public TypeVal visit(SaInstBloc node) throws Exception
+    {
+		defaultIn(node);
+		node.getVal().accept(this);
+		defaultOut(node);
+		return null;
+    }
+    
+    public TypeVal visit(SaInstSi node) throws Exception
+    {
+		defaultIn(node);
+		TypeVal test = node.getTest().accept(this);
+		if(test.valBool && node.getAlors() != null)
+			node.getAlors().accept(this);
+		if(!test.valBool && node.getSinon() != null)
+			node.getSinon().accept(this);
+		defaultOut(node);
+		return null;
+    }
+
+// INST -> ret EXP 
+    public TypeVal visit(SaInstRetour node) throws Exception
+    {
+		defaultIn(node);
+		curEnv.setReturnValue(node.getVal().accept(this));
+		stop = true;
+		defaultOut(node);
+		return null;
+    }
+
+    
+    public TypeVal visit(SaLExp node) throws Exception
+    {
+		defaultIn(node);
+		node.getTete().accept(this);
+		if(node.getQueue() != null)
+			node.getQueue().accept(this);
+		defaultOut(node);
+		return null;
+    }
+
+    public TypeVal visit(SaVarIndicee node) throws Exception
+    {
+		defaultIn(node);
+		node.getIndice().accept(this);
+		TypeVal indice = node.getIndice().accept(this);
+		defaultOut(node);
+		return getVarGlobIndicee(node, indice);
+    }
+    
+}
diff --git a/src/sa/SaExp.java b/src/sa/SaExp.java
new file mode 100644
index 0000000000000000000000000000000000000000..81cbf3cd71f316298250651539dfb8addb9f692c
--- /dev/null
+++ b/src/sa/SaExp.java
@@ -0,0 +1,6 @@
+package sa;
+import util.Type;
+
+public interface SaExp extends SaNode {
+    public Type getType();
+}
diff --git a/src/sa/SaExpAdd.java b/src/sa/SaExpAdd.java
new file mode 100644
index 0000000000000000000000000000000000000000..0041eed4950087de222de4c9739a438e40b3d301
--- /dev/null
+++ b/src/sa/SaExpAdd.java
@@ -0,0 +1,26 @@
+package sa;
+import util.Type;
+
+public class SaExpAdd implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpAdd(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.ENTIER;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+    public String toString(){
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpAnd.java b/src/sa/SaExpAnd.java
new file mode 100644
index 0000000000000000000000000000000000000000..df94c5b74eddbefb67adfd2fa7b3f0eb1357c057
--- /dev/null
+++ b/src/sa/SaExpAnd.java
@@ -0,0 +1,26 @@
+package sa;
+import util.Type;
+
+public class SaExpAnd implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpAnd(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpAppel.java b/src/sa/SaExpAppel.java
new file mode 100644
index 0000000000000000000000000000000000000000..611aa6a106ea92f6dd2198b5706294cf127dd00d
--- /dev/null
+++ b/src/sa/SaExpAppel.java
@@ -0,0 +1,25 @@
+package sa;
+import util.Type;
+
+public class SaExpAppel implements SaExp{
+    private SaAppel val;
+
+    public SaExpAppel(SaAppel val){
+	this.val = val;
+    }
+
+    public SaAppel getVal(){return this.val;}
+
+    public Type getType(){
+	return val.getType();
+    }
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + val + ")";
+    }
+}
diff --git a/src/sa/SaExpDiv.java b/src/sa/SaExpDiv.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc2db6e65ad14122a34b40d2b79f5ba9a6abe3c0
--- /dev/null
+++ b/src/sa/SaExpDiv.java
@@ -0,0 +1,27 @@
+package sa;
+import util.Type;
+
+public class SaExpDiv implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpDiv(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.ENTIER;
+    }
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpEqual.java b/src/sa/SaExpEqual.java
new file mode 100644
index 0000000000000000000000000000000000000000..01eeb010443570e08ce02b43b5af0834c8df4bef
--- /dev/null
+++ b/src/sa/SaExpEqual.java
@@ -0,0 +1,27 @@
+package sa;
+import util.Type;
+
+public class SaExpEqual implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpEqual(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpFaux.java b/src/sa/SaExpFaux.java
new file mode 100644
index 0000000000000000000000000000000000000000..125956f06d4a0c057364ef77e4ad44034b31eb01
--- /dev/null
+++ b/src/sa/SaExpFaux.java
@@ -0,0 +1,28 @@
+package sa;
+import util.Type;
+
+public class SaExpFaux implements SaExp{
+    private final boolean val;
+
+    public SaExpFaux(){
+	this.val = false;
+    }
+
+    public boolean getVal(){
+	return this.val;
+    }
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "faux";
+    }
+}
diff --git a/src/sa/SaExpInf.java b/src/sa/SaExpInf.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f7c54a50048cd9745749d5c9dec52b6c89522a1
--- /dev/null
+++ b/src/sa/SaExpInf.java
@@ -0,0 +1,28 @@
+package sa;
+import util.Type;
+
+public class SaExpInf implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpInf(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception {
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpInt.java b/src/sa/SaExpInt.java
new file mode 100644
index 0000000000000000000000000000000000000000..10bd6d6b6b674fed031f384502667ffc3c1d6717
--- /dev/null
+++ b/src/sa/SaExpInt.java
@@ -0,0 +1,26 @@
+package sa;
+import util.Type;
+
+public class SaExpInt implements SaExp{
+    private int val;
+
+    public SaExpInt(int val){
+	this.val = val;
+    }
+
+    public int getVal(){
+	return this.val;
+    }
+    
+    public Type getType(){
+	return Type.ENTIER;
+    }
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return Integer.toString(val);
+    }
+}
diff --git a/src/sa/SaExpLire.java b/src/sa/SaExpLire.java
new file mode 100644
index 0000000000000000000000000000000000000000..53d8520143f187cf397e344a70f19a3fd72d26b6
--- /dev/null
+++ b/src/sa/SaExpLire.java
@@ -0,0 +1,21 @@
+package sa;
+import util.Type;
+
+public class SaExpLire implements SaExp{
+
+    public SaExpLire(){
+    }
+
+    public Type getType(){
+	return Type.ENTIER;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName();
+    }
+}
diff --git a/src/sa/SaExpMult.java b/src/sa/SaExpMult.java
new file mode 100644
index 0000000000000000000000000000000000000000..597038dc0fdade0639bdf52e2eb622dbf347055a
--- /dev/null
+++ b/src/sa/SaExpMult.java
@@ -0,0 +1,27 @@
+package sa;
+import util.Type;
+
+public class SaExpMult implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpMult(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.ENTIER;
+    }
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpNot.java b/src/sa/SaExpNot.java
new file mode 100644
index 0000000000000000000000000000000000000000..60a1c08aa6cc3097f205d3f51cb159117946666a
--- /dev/null
+++ b/src/sa/SaExpNot.java
@@ -0,0 +1,26 @@
+package sa;
+import util.Type;
+
+public class SaExpNot implements SaExp{
+    private SaExp op1;
+
+    public SaExpNot(SaExp op1){
+	this.op1 = op1;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return null;}
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + ")";
+    }
+}
diff --git a/src/sa/SaExpOr.java b/src/sa/SaExpOr.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec9807d3a9f600483df235ebd151d6f356e9dcfb
--- /dev/null
+++ b/src/sa/SaExpOr.java
@@ -0,0 +1,28 @@
+package sa;
+import util.Type;
+
+public class SaExpOr implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpOr(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpSub.java b/src/sa/SaExpSub.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf02733028e29275798694ded4d36faf7591da3c
--- /dev/null
+++ b/src/sa/SaExpSub.java
@@ -0,0 +1,28 @@
+package sa;
+import util.Type;
+
+public class SaExpSub implements SaExp{
+    private SaExp op1;
+    private SaExp op2;
+
+    public SaExpSub(SaExp op1, SaExp op2){
+	this.op1 = op1;
+	this.op2 = op2;
+    }
+
+    public SaExp getOp1(){return this.op1;}
+    public SaExp getOp2(){return this.op2;}
+    
+    public Type getType(){
+	return Type.ENTIER;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")";
+    }
+}
diff --git a/src/sa/SaExpVar.java b/src/sa/SaExpVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..f983c1fdb0e37ee2bf0ab8cd1242f7f596f5023f
--- /dev/null
+++ b/src/sa/SaExpVar.java
@@ -0,0 +1,24 @@
+package sa;
+import util.Type;
+
+public class SaExpVar implements SaExp{
+    private SaVar var;
+
+    public SaExpVar(SaVar var){
+	this.var = var;
+    }
+
+    public SaVar getVar(){return this.var;}
+
+    public Type getType(){
+	return this.var.getTsItem().getType();
+    }
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + var + ")";
+    }
+}
diff --git a/src/sa/SaExpVrai.java b/src/sa/SaExpVrai.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef992113637d8e746629cfdb508d8d6e817dfe5f
--- /dev/null
+++ b/src/sa/SaExpVrai.java
@@ -0,0 +1,27 @@
+package sa;
+import util.Type;
+
+public class SaExpVrai implements SaExp{
+    private final boolean val;
+
+    public SaExpVrai(){
+	this.val = true;
+    }
+
+    public boolean getVal(){
+	return this.val;
+    }
+    
+    public Type getType(){
+	return Type.BOOL;
+    }
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "vrai";
+    }
+}
diff --git a/src/sa/SaInst.java b/src/sa/SaInst.java
new file mode 100644
index 0000000000000000000000000000000000000000..409ef53d5f0a324cc3eb7dde5929e1deeeb2f1ef
--- /dev/null
+++ b/src/sa/SaInst.java
@@ -0,0 +1,5 @@
+package sa;
+
+public interface SaInst extends SaNode {
+    
+}
diff --git a/src/sa/SaInstAffect.java b/src/sa/SaInstAffect.java
new file mode 100644
index 0000000000000000000000000000000000000000..126f741d3e900f468a368ad089faaf9c18c83e0d
--- /dev/null
+++ b/src/sa/SaInstAffect.java
@@ -0,0 +1,22 @@
+package sa;
+
+public class SaInstAffect implements SaInst{
+    private SaVar lhs;
+    private SaExp rhs;
+
+    public SaInstAffect(SaVar lhs, SaExp rhs){
+	this.lhs = lhs;
+	this.rhs = rhs;
+    }
+    public SaVar getLhs(){return this.lhs;}
+    public SaExp getRhs(){return this.rhs;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName()+ " " + lhs + " " + rhs + ")";
+    }
+}
diff --git a/src/sa/SaInstBloc.java b/src/sa/SaInstBloc.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f13f49c6bccdc48b6fc4bda8cdbe9e8a417ffc1
--- /dev/null
+++ b/src/sa/SaInstBloc.java
@@ -0,0 +1,19 @@
+package sa;
+
+public class SaInstBloc implements SaInst{
+    private SaLInst val;
+
+    public SaInstBloc(SaLInst val){
+	this.val = val;
+    }
+
+    public SaLInst getVal(){return this.val;}
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + val + ")";
+    }
+}
diff --git a/src/sa/SaInstEcriture.java b/src/sa/SaInstEcriture.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ba2af340865b3579f6a28de66f28ce3b8797700
--- /dev/null
+++ b/src/sa/SaInstEcriture.java
@@ -0,0 +1,20 @@
+package sa;
+
+public class SaInstEcriture implements SaInst{
+    private SaExp arg;
+
+    public SaInstEcriture(SaExp arg){
+	this.arg = arg;
+    }
+
+    public SaExp getArg(){return this.arg;}
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + arg + ")";
+    }
+}
diff --git a/src/sa/SaInstRetour.java b/src/sa/SaInstRetour.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3993e88ee81b9f5584e2a3da6dff5911d50f718
--- /dev/null
+++ b/src/sa/SaInstRetour.java
@@ -0,0 +1,24 @@
+package sa;
+import util.Type;
+
+public class SaInstRetour implements SaInst{
+    private SaExp val;
+
+    public SaInstRetour(SaExp val){
+	this.val = val;
+    }
+
+    public Type getType(){
+	return val.getType();
+    }
+    public SaExp getVal(){return this.val;}
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + val + ")";
+    }
+}
diff --git a/src/sa/SaInstSi.java b/src/sa/SaInstSi.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc8c1d7a1c02b1da58a2e8dcaec1d2b9f2b1cd11
--- /dev/null
+++ b/src/sa/SaInstSi.java
@@ -0,0 +1,26 @@
+package sa;
+
+public class SaInstSi implements SaInst{
+    private SaExp test;
+    private SaInst alors;
+    private SaInst sinon;
+
+    public SaInstSi(SaExp test, SaInst alors, SaInst sinon){
+	this.test = test;
+	this.alors = alors;
+	this.sinon = sinon;
+    }
+
+    public SaExp getTest(){return this.test;}
+    public SaInst getAlors(){return this.alors;}
+    public SaInst getSinon(){return this.sinon;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + test + " " + alors + " " + sinon + ")";
+    }
+}
diff --git a/src/sa/SaInstTantQue.java b/src/sa/SaInstTantQue.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfc87e1b053b28b22281134d6dc8756108cf2dff
--- /dev/null
+++ b/src/sa/SaInstTantQue.java
@@ -0,0 +1,23 @@
+package sa;
+
+public class SaInstTantQue implements SaInst{
+    private SaExp test;
+    private SaInst faire;
+
+    public SaInstTantQue(SaExp test, SaInst faire){
+	this.test = test;
+	this.faire = faire;
+    }
+
+    public SaExp getTest(){return this.test;}
+    public SaInst getFaire(){return this.faire;}
+
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + test + " " +  faire + ")";
+    }
+}
diff --git a/src/sa/SaLDecFonc.java b/src/sa/SaLDecFonc.java
new file mode 100644
index 0000000000000000000000000000000000000000..73135aeaf1b30f4684851bd6f0dc90f0f97dbe73
--- /dev/null
+++ b/src/sa/SaLDecFonc.java
@@ -0,0 +1,28 @@
+package sa;
+
+public class SaLDecFonc implements SaNode{
+    private SaDecFonc tete;
+    private SaLDecFonc queue;
+
+    public SaLDecFonc(SaDecFonc tete, SaLDecFonc queue){
+	this.tete = tete;
+	this.queue = queue;
+    }
+
+    public SaDecFonc getTete(){return this.tete;}
+    public SaLDecFonc getQueue(){return this.queue;}
+
+    public int length(){
+	if(this.queue == null) return 1;
+	return 1 + this.queue.length() ;
+    }
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")";
+    }
+
+}
diff --git a/src/sa/SaLDecVar.java b/src/sa/SaLDecVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f69dc3ed20db5c58d68cdff7dc21d20a1883d7d
--- /dev/null
+++ b/src/sa/SaLDecVar.java
@@ -0,0 +1,27 @@
+package sa;
+
+public class SaLDecVar implements SaNode{
+    private SaDecVar tete;
+    private SaLDecVar queue;
+
+    public SaLDecVar(SaDecVar tete, SaLDecVar queue){
+	this.tete = tete;
+	this.queue = queue;
+    }
+
+    public SaDecVar getTete(){return this.tete;}
+    public SaLDecVar getQueue(){return this.queue;}
+
+    public int length(){
+	if(this.queue == null) return 1;
+	return 1 + this.queue.length() ;
+    }
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception {
+        return visitor.visit(this);
+    }
+    public String toString(){
+        return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")";
+    }
+
+}
diff --git a/src/sa/SaLExp.java b/src/sa/SaLExp.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6e489fd7262d334388bd399ff5e793e5718675f
--- /dev/null
+++ b/src/sa/SaLExp.java
@@ -0,0 +1,30 @@
+package sa;
+
+public class SaLExp implements SaNode{
+    private SaExp tete;
+    private SaLExp queue;
+
+    public SaLExp(SaExp tete, SaLExp queue){
+	this.tete = tete;
+	this.queue = queue;
+    }
+
+    public SaExp getTete(){return this.tete;}
+    public SaLExp getQueue(){return this.queue;}
+
+    public int length(){
+	if(this.queue == null) return 1;
+	return 1 + this.queue.length() ;
+    }
+    
+
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")";
+    }
+}
diff --git a/src/sa/SaLInst.java b/src/sa/SaLInst.java
new file mode 100644
index 0000000000000000000000000000000000000000..29c7cd06d8a6c5a810b0b0750485f7e455ea08ff
--- /dev/null
+++ b/src/sa/SaLInst.java
@@ -0,0 +1,23 @@
+package sa;
+
+public class SaLInst implements SaNode{
+    private SaInst tete;
+    private SaLInst queue;
+
+    public SaLInst(SaInst tete, SaLInst queue){
+	this.tete = tete;
+	this.queue = queue;
+    }
+
+    public SaInst getTete(){return this.tete;}
+    public SaLInst getQueue(){return this.queue;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    public String toString(){
+        return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue +")";
+    }
+
+}
diff --git a/src/sa/SaNode.java b/src/sa/SaNode.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd65a017106d6bc8e3da3cc141677127b2d6a18e
--- /dev/null
+++ b/src/sa/SaNode.java
@@ -0,0 +1,6 @@
+package sa;
+
+public interface SaNode{
+    public <T> T accept(SaVisitor <T> visitor) throws Exception;
+}
+
diff --git a/src/sa/SaProg.java b/src/sa/SaProg.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0081db250d89a1d48a676f1f13f987192b056e3
--- /dev/null
+++ b/src/sa/SaProg.java
@@ -0,0 +1,21 @@
+package sa;
+
+public class SaProg implements SaNode{
+    private SaLDecVar variables;
+    private SaLDecFonc fonctions;
+
+    public SaProg(SaLDecVar variables, SaLDecFonc fonctions){
+	this.variables = variables;
+	this.fonctions = fonctions;
+    }
+
+    public SaLDecVar getVariables(){return this.variables;}
+    public SaLDecFonc getFonctions(){return this.fonctions;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+    public String toString(){
+        return "(" + this.getClass().getSimpleName() + " " + variables  + " " + fonctions +")";
+    }
+}
diff --git a/src/sa/SaTypeCheck.java b/src/sa/SaTypeCheck.java
new file mode 100644
index 0000000000000000000000000000000000000000..60e71efec1cba615a2f3bb32f6c710652f1f5086
--- /dev/null
+++ b/src/sa/SaTypeCheck.java
@@ -0,0 +1,32 @@
+package sa;
+import util.Type;
+import util.Error;
+import ts.*;
+
+public class SaTypeCheck extends SaDepthFirstVisitor <Void>{
+    private TsItemFct fonctionCourante;
+
+    public SaTypeCheck(SaNode root)
+    {
+		try{
+			root.accept(this);
+		} catch(ErrorException e){
+			System.err.print("ERREUR DE TYPAGE : ");
+			System.err.println(e.getMessage());
+			System.exit(e.getCode());
+		} catch(Exception e){}
+	}
+
+    public void defaultIn(SaNode node)
+    {
+		//			System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(SaNode node)
+    {
+		//		System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+
+
+}
diff --git a/src/sa/SaVar.java b/src/sa/SaVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e5536ed3b3374d9272e3a86b79caf0410852638
--- /dev/null
+++ b/src/sa/SaVar.java
@@ -0,0 +1,6 @@
+package sa;
+import ts.*;
+
+public interface SaVar extends SaNode {
+    TsItemVar getTsItem();
+}
diff --git a/src/sa/SaVarIndicee.java b/src/sa/SaVarIndicee.java
new file mode 100644
index 0000000000000000000000000000000000000000..d125b11b4d0488fd44e0fe18b0c340835ff9dbd6
--- /dev/null
+++ b/src/sa/SaVarIndicee.java
@@ -0,0 +1,27 @@
+package sa;
+import ts.*;
+
+public class SaVarIndicee implements SaVar{
+    private String nom;
+    private SaExp indice;
+    public TsItemVar tsItem;
+    
+    public SaVarIndicee(String nom, SaExp indice){
+	this.nom = nom;
+	this.indice = indice;
+	this.tsItem = null;
+    }
+
+    public TsItemVar getTsItem(){return this.tsItem;}
+    public String getNom(){return this.nom;}
+    public SaExp getIndice(){return this.indice;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName() + " " + nom + " " + indice +")";
+    }
+}
diff --git a/src/sa/SaVarSimple.java b/src/sa/SaVarSimple.java
new file mode 100644
index 0000000000000000000000000000000000000000..d496e74ac0ab58ec1cc908cb8e0fe2331e13976f
--- /dev/null
+++ b/src/sa/SaVarSimple.java
@@ -0,0 +1,24 @@
+package sa;
+import ts.*;
+
+public class SaVarSimple implements SaVar{
+    public String nom;
+    public TsItemVarSimple tsItem;
+
+    public SaVarSimple(String nom){
+	this.nom = nom;
+	this.tsItem = null;
+    }
+
+    public String getNom(){return this.nom;}
+    public TsItemVarSimple getTsItem(){return this.tsItem;}
+    
+    public <T> T accept(SaVisitor <T> visitor) throws Exception{
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + this.getClass().getSimpleName()+ " " + nom + ")";
+    }
+}
diff --git a/src/sa/SaVisitor.java b/src/sa/SaVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d28bb7870f422fa6caa7a50066a819b40fa6c11
--- /dev/null
+++ b/src/sa/SaVisitor.java
@@ -0,0 +1,38 @@
+package sa;
+
+interface SaVisitor <T> {
+    public T visit(SaProg node) throws Exception;
+    public T visit(SaInstEcriture node) throws Exception;
+    public T visit(SaInstTantQue node) throws Exception;
+    public T visit(SaInstBloc node) throws Exception;
+    public T visit(SaInstSi node) throws Exception;
+    public T visit(SaInstAffect node) throws Exception;
+    public T visit(SaInstRetour node) throws Exception;
+    public T visit(SaLInst node) throws Exception;
+    public T visit(SaDecFonc node) throws Exception;
+    public T visit(SaDecVar node) throws Exception;
+    public T visit(SaDecTab node) throws Exception;
+    //    public T visit(SaLDec node) throws Exception;
+    public T visit(SaLDecVar node) throws Exception;
+    public T visit(SaLDecFonc node) throws Exception;
+    public T visit(SaVarSimple node) throws Exception;
+    public T visit(SaVarIndicee node) throws Exception;
+    public T visit(SaAppel node) throws Exception;
+    public T visit(SaExp node) throws Exception;
+    public T visit(SaExpLire node) throws Exception;
+    public T visit(SaExpInt node) throws Exception;
+    public T visit(SaExpVrai node) throws Exception;
+    public T visit(SaExpFaux node) throws Exception;
+    public T visit(SaExpVar node) throws Exception;
+    public T visit(SaExpAppel node) throws Exception;
+    public T visit(SaExpAdd node) throws Exception;
+    public T visit(SaExpSub node) throws Exception;
+    public T visit(SaExpMult node) throws Exception;
+    public T visit(SaExpDiv node) throws Exception;
+    public T visit(SaExpInf node) throws Exception;
+    public T visit(SaExpEqual node) throws Exception;
+    public T visit(SaExpAnd node) throws Exception;
+    public T visit(SaExpOr node) throws Exception;
+    public T visit(SaExpNot node) throws Exception;
+    public T visit(SaLExp node) throws Exception;
+}
diff --git a/src/sa/Sc2sa.java b/src/sa/Sc2sa.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bc4abd6ec52633b975ecfb731e2db8b18e8f1e5
--- /dev/null
+++ b/src/sa/Sc2sa.java
@@ -0,0 +1,43 @@
+package sa;
+import lParser.analysis.*;
+import lParser.node.*;
+import util.Type;
+
+public class Sc2sa extends DepthFirstAdapter
+{
+    private SaNode returnValue;
+    private Type returnType;
+    private SaProg saRoot = null;
+
+    public void defaultIn(@SuppressWarnings("unused") Node node)
+    {
+	//System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(@SuppressWarnings("unused") Node node)
+    {
+	//System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+    
+    public SaProg getRoot()
+    {
+	return this.saRoot;
+    }
+
+
+    // exp3 = {plus} exp3 plus exp4 
+    /*    @Override
+    public void caseAPlusExp3(APlusExp3 node)
+    {
+	SaExp op1 = null;
+	SaExp op2 = null;
+        inAPlusExp3(node);
+	node.getExp3().apply(this);
+	op1 = (SaExp) this.returnValue;
+	node.getExp4().apply(this);
+	op2 = (SaExp) this.returnValue;
+	this.returnValue = new SaExpAdd(op1, op2);
+        outAPlusExp3(node);
+	}*/
+}
+
diff --git a/src/sa/TypeVal.java b/src/sa/TypeVal.java
new file mode 100644
index 0000000000000000000000000000000000000000..54cf58ba35f3d0aa29407d82b6b81f1a0f8aab77
--- /dev/null
+++ b/src/sa/TypeVal.java
@@ -0,0 +1,31 @@
+package sa;
+import util.Type;
+
+public class TypeVal{
+    public Type type;
+    public boolean valBool;
+    public int valInt;
+
+    public TypeVal(int val)
+    {
+	type = Type.ENTIER;
+	valInt = val;
+    }
+    
+    public TypeVal(boolean val)
+    {
+	type = Type.BOOL;
+	valBool = val;
+    }
+
+    public String toString(){
+	if(type == Type.BOOL){
+	    return (valBool == true)? String.valueOf(1): String.valueOf(0);
+	}
+	else{
+	    return String.valueOf(valInt);
+	}
+    }
+
+    
+}
diff --git a/src/sc/Sc2Xml.java b/src/sc/Sc2Xml.java
new file mode 100644
index 0000000000000000000000000000000000000000..a70781c44459ff2a62334043b223762448126d62
--- /dev/null
+++ b/src/sc/Sc2Xml.java
@@ -0,0 +1,48 @@
+package sc;
+import java.io.*;
+import lParser.analysis.*;
+import lParser.node.*;
+
+public class Sc2Xml extends DepthFirstAdapter
+{
+    private int indentation;
+    private String baseFileName;
+    private String fileName;
+    private PrintStream out;
+    
+    public Sc2Xml(String baseFileName)
+    {
+
+	if (baseFileName == null){
+	    this.out = System.out;
+	    
+	}
+	else{
+	    try {
+		this.baseFileName = baseFileName;
+		this.fileName = baseFileName + ".sc";
+		this.out = new PrintStream(this.fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+    }
+    
+    
+    public void defaultIn(@SuppressWarnings("unused") Node node)
+    {
+	for(int i = 0; i < this.indentation; i++){this.out.print(" ");}
+	this.indentation++;
+	this.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(@SuppressWarnings("unused") Node node)
+    {
+	this.indentation--;
+	for(int i = 0; i < this.indentation; i++){this.out.print(" ");}
+	this.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+}
diff --git a/src/ts/Sa2ts.java b/src/ts/Sa2ts.java
new file mode 100644
index 0000000000000000000000000000000000000000..50a80a6c17ef87000261b8a1dbf16dd07675709e
--- /dev/null
+++ b/src/ts/Sa2ts.java
@@ -0,0 +1,36 @@
+package ts;
+import sa.*;
+import util.Error;
+
+public class Sa2ts extends SaDepthFirstVisitor <Void> {
+    enum Context {
+	LOCAL,
+	GLOBAL,
+	PARAM
+    }
+    
+    private Ts tableGlobale;
+    private Ts tableLocaleCourante;
+    private Context context;
+    
+    public Ts getTableGlobale(){return this.tableGlobale;}
+
+    public Sa2ts()
+    {
+	tableGlobale = new Ts();
+	tableLocaleCourante = null;
+	context = Context.GLOBAL;
+    }
+
+    public void defaultIn(SaNode node)
+    {
+	//	System.out.println("<" + node.getClass().getSimpleName() + ">");
+    }
+
+    public void defaultOut(SaNode node)
+    {
+	//	System.out.println("</" + node.getClass().getSimpleName() + ">");
+    }
+
+
+}
diff --git a/src/ts/Ts.java b/src/ts/Ts.java
new file mode 100644
index 0000000000000000000000000000000000000000..d95fb75ed1196eb28dbdeee9d450bbbe5f847082
--- /dev/null
+++ b/src/ts/Ts.java
@@ -0,0 +1,147 @@
+package ts;
+import java.io.*;
+import java.util.*;
+import sa.*;
+import util.Type;
+
+public class Ts
+{
+    public Map< String, TsItemFct> fonctions;
+    public Map< String, TsItemVar> variables;
+    private int adrVarCourante;
+    private int adrArgCourante;
+
+    public int getAdrVarCourante(){return adrVarCourante;}
+    public int getAdrArgCourante(){return adrArgCourante;}
+
+    public Ts(){
+	this.fonctions = new HashMap< String, TsItemFct>();
+	this.variables = new HashMap< String, TsItemVar>();
+	this.adrVarCourante = 0;
+	this.adrArgCourante = 0;
+    }
+    
+    public TsItemVar addVar(String identif, Type type)
+    {
+	TsItemVar item = new TsItemVarSimple(identif, type);
+	item.portee = this;
+	item.adresse = this.adrVarCourante;
+	item.isParam = false;
+	this.adrVarCourante += type.taille();
+	this.variables.put(identif, item);
+	return item;
+    }
+
+    public TsItemVar addParam(String identif, Type type)
+    {
+	TsItemVar item = new TsItemVarSimple(identif, type);
+	item.portee = this;
+	item.adresse = this.adrArgCourante;
+	item.isParam = true;
+	this.adrArgCourante += type.taille();
+	this.variables.put(identif, item);
+	return item;
+    }
+
+    public TsItemVar addTab(String identif, Type type, int taille)
+    {
+	TsItemVar item = new TsItemVarTab(identif, type, taille);
+	item.portee = this;
+	item.adresse = this.adrVarCourante;
+	this.adrVarCourante += taille * type.taille();
+	this.variables.put(identif, item);
+	return item;
+    }
+
+    public TsItemFct addFct(String identif, Type typeRetour, int nbArgs, Ts table, SaDecFonc saDecFonc)
+    {
+	TsItemFct item = new TsItemFct(identif, typeRetour, nbArgs, table, saDecFonc);
+	this.fonctions.put(identif, item);
+	return item;
+    }
+
+    public TsItemVar getVar(String identif)
+    {
+	return variables.get(identif);
+    }
+    
+    public TsItemFct getFct(String identif)
+    {
+	return fonctions.get(identif);
+    }
+    
+    public Ts getTableLocale(String identif){
+	TsItemFct item = this.fonctions.get(identif);
+	if(item == null)
+	    return null;
+	else
+	    return item.getTable();
+    }
+    
+	 
+    public void affiche(PrintStream out){
+	ArrayList< Map.Entry< String, TsItemVar> > stVar = new ArrayList<Map.Entry< String, TsItemVar>>(this.variables.entrySet());
+	Collections.sort(stVar, new Comparator<Map.Entry< String, TsItemVar>>() {
+		@Override
+		public int compare(Map.Entry< String, TsItemVar> entry1, Map.Entry< String, TsItemVar> entry2)
+		{
+		    return entry1.getKey().compareTo(entry2.getKey());
+		}
+	    });
+	for (Map.Entry< String, TsItemVar> me:stVar){ 
+	    out.println(me.getValue());
+	    //	    out.println(me.getKey() + ":\t" + me.getValue());
+	}
+	
+	ArrayList< Map.Entry< String, TsItemFct> > stFct = new ArrayList<Map.Entry< String, TsItemFct>>(this.fonctions.entrySet());
+	Collections.sort(stFct, new Comparator<Map.Entry< String, TsItemFct>>() {
+		@Override
+		public int compare(Map.Entry< String, TsItemFct> entry1, Map.Entry< String, TsItemFct> entry2)
+		{
+		    return entry1.getKey().compareTo(entry2.getKey());
+		}
+	    });
+	for (Map.Entry< String, TsItemFct> me:stFct){ 
+	    out.println(me.getValue());
+	    //	    out.println(me.getKey() + ":\t" + me.getValue());
+	}
+    }
+	
+    public void afficheTablesLocales(PrintStream out){
+	ArrayList< Map.Entry< String, TsItemFct> > st = new ArrayList<Map.Entry< String, TsItemFct>>(this.fonctions.entrySet());
+	Collections.sort(st, new Comparator<Map.Entry< String, TsItemFct>>() {
+		@Override
+		public int compare(Map.Entry< String, TsItemFct> entry1, Map.Entry< String, TsItemFct> entry2)
+		{
+		    return entry1.getKey().compareTo(entry2.getKey());
+		}
+	    });
+	for (Map.Entry< String, TsItemFct> me:st){
+	    if(me.getValue().getTable() != null){
+		out.println("TABLE LOCALE : " + me.getKey());
+		me.getValue().getTable().affiche(out);
+	    }
+	}
+    }
+    
+    public void afficheTout(String baseFileName){
+	String fileName;
+	PrintStream out = System.out;
+	
+	if (baseFileName != null){
+	    try {
+		baseFileName = baseFileName;
+		fileName = baseFileName + ".ts";
+		out = new PrintStream(fileName);
+	    }
+	    
+	    catch (IOException e) {
+		System.err.println("Error: " + e.getMessage());
+	    }
+	}
+       	out.println("TABLE GLOBALE");
+	this.affiche(out);
+	this.afficheTablesLocales(out);
+    }
+
+}
diff --git a/src/ts/TsItemFct.java b/src/ts/TsItemFct.java
new file mode 100644
index 0000000000000000000000000000000000000000..03e87f65dda8622fe8f5de40416054f2ca1d00a8
--- /dev/null
+++ b/src/ts/TsItemFct.java
@@ -0,0 +1,30 @@
+package ts;
+import sa.*;
+import util.Type;
+
+
+public class TsItemFct {
+    public String identif;
+    public int nbArgs;
+    public Ts table;
+    public SaDecFonc saDecFonc;
+    public Type typeRetour;
+    
+    public TsItemFct(String identif, Type typeRetour, int nbArgs, Ts table, SaDecFonc saDecFonc){
+	this.identif = identif;
+	this.nbArgs = nbArgs;
+	this.table = table;
+	this.saDecFonc = saDecFonc;
+	this.typeRetour = typeRetour;
+    }
+
+    public int getNbArgs(){return this.nbArgs;}
+    public Ts getTable(){return this.table;}
+    public Type getTypeRetour(){return this.typeRetour;}
+    public String getIdentif(){return this.identif;}
+    public String toString(){
+    	return this.identif +  "\tFCT\t" + typeRetour + "\t" + this.nbArgs;
+    }
+
+}
+
diff --git a/src/ts/TsItemVar.java b/src/ts/TsItemVar.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dae2bb896d63d316875f99ff8a3a45023110c49
--- /dev/null
+++ b/src/ts/TsItemVar.java
@@ -0,0 +1,20 @@
+package ts;
+import util.Type;
+
+public abstract class TsItemVar {
+    public Ts      portee;
+    public int     adresse;
+    public String  identif;
+    public int     taille;
+    public boolean isParam;
+    public Type    type;
+
+    public int    getAdresse(){return this.adresse;}
+    public String getIdentif(){return this.identif;}
+    public Ts     getPortee() {return this.portee;}
+    public Type   getType()   {return this.type;}
+    public int    getTaille(){return this.taille;}
+    
+    
+}
+
diff --git a/src/ts/TsItemVarSimple.java b/src/ts/TsItemVarSimple.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae2a555a1149f34755bfb7a4ae4dde02a5345309
--- /dev/null
+++ b/src/ts/TsItemVarSimple.java
@@ -0,0 +1,22 @@
+package ts;
+import util.Type;
+
+public class TsItemVarSimple extends TsItemVar{
+    public TsItemVarSimple(String identif, Type type){
+	this.identif = identif;
+	this.adresse = 0;
+	this.portee =  null;
+	this.taille =  1;
+	this.isParam = false;
+	this.type =    type;
+    }
+
+    public String toString(){
+	if(this.isParam)
+	    return this.identif + "\tPARAM\t" + this.type + "\t" + this.adresse;
+	else
+	    return this.identif + "\tVAR  \t" + this.type + "\t" + this.adresse;
+    }
+    
+}
+
diff --git a/src/ts/TsItemVarTab.java b/src/ts/TsItemVarTab.java
new file mode 100644
index 0000000000000000000000000000000000000000..56c0a116605fb11714826d27714c2aa3b046cc5c
--- /dev/null
+++ b/src/ts/TsItemVarTab.java
@@ -0,0 +1,19 @@
+package ts;
+import util.Type;
+
+public class TsItemVarTab  extends TsItemVar{
+    public TsItemVarTab(String identif, Type type, int taille){
+	this.identif = identif;
+	this.adresse = 0;
+	this.portee = null;
+	this.taille = taille;
+	this.isParam = false;
+	this.type = type;
+    }
+
+    public String toString(){
+	    return this.identif + "\tTAB  \t" + this.type + "\t" + this.adresse + "\t" + this.taille;
+    }
+    
+}
+
diff --git a/src/ts/TsParser.java b/src/ts/TsParser.java
new file mode 100644
index 0000000000000000000000000000000000000000..509bff6ee29d53d5f75a8d3928b1c0eb8277ac2a
--- /dev/null
+++ b/src/ts/TsParser.java
@@ -0,0 +1,71 @@
+package ts;
+
+import ts.Ts;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import util.Type;
+
+public class TsParser {
+    private Ts tableCourante = null;
+    private Ts tableGlobale = null;
+
+    public TsParser(){
+
+    }
+    
+    public Ts parse(String filePath){
+        try {
+            Files.lines(Paths.get(filePath)).forEachOrdered(this::processLine);;
+        } catch(IOException e){
+            e.printStackTrace();
+        }
+        return tableGlobale;
+    }
+
+    private void processLine(String line){
+//		System.out.println(line);
+        var tokens = line.split("([ ]|[\t])+");
+		if(tokens[1].equals("GLOBALE")){
+			tableGlobale = new Ts();
+			tableCourante = tableGlobale;
+			return;
+		}
+		if(tokens[1].equals("LOCALE")){
+			tableCourante = tableGlobale.getFct(tokens[3]).getTable();
+			return;
+		}
+		if(tokens[1].equals("VAR")){
+			tableCourante.addVar(tokens[0], Type.fromString(tokens[2]));
+			return;
+		}
+		if(tokens[1].equals("PARAM")){
+			tableCourante.addParam(tokens[0], Type.fromString(tokens[2]));
+			return;
+		}
+		if(tokens[1].equals("TAB")){
+			tableCourante.addTab(tokens[0], Type.fromString(tokens[2]), Integer.parseInt(tokens[4]));
+			return;
+		}
+		if(tokens[1].equals("FCT")){
+			tableGlobale.addFct(tokens[0], Type.fromString(tokens[2]), Integer.parseInt(tokens[3]), new Ts(), null);
+			return;
+		}
+    }
+    /*
+    public static void main(String args[]){
+        var parser = new SymbolsTableParser();
+        var r = parser.parse("function.ts");
+        System.out.println("---Table Globale---");
+        r.affiche(System.out);
+        System.out.println("---Tables Locales---");
+        r.afficheTablesLocales(System.out);
+	}*/
+}
diff --git a/src/util/Error.java b/src/util/Error.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a7500040e46a9e9d914f8865cb653da75a2c073
--- /dev/null
+++ b/src/util/Error.java
@@ -0,0 +1,21 @@
+package util;
+
+public enum Error{
+    NOERROR(0, "sortie normale"),
+    TYPE(3, "erreur de types"),
+    TS(4, "table des symboles"),
+    SYNT(5,"erreur de syntaxe"),
+    LEX(6, "lexical error");
+
+    private final String message;
+    private final int code;
+    
+    Error(int code, String message){
+	this.code = code;
+	this.message = message;
+    }
+
+    public String toString(){return message;}
+    public String message(){return message;}
+    public int code(){return code;}
+}
diff --git a/src/util/Memory.java b/src/util/Memory.java
new file mode 100644
index 0000000000000000000000000000000000000000..688a9da4134d2c2fcb46c61bedbeda7d4d5ebe70
--- /dev/null
+++ b/src/util/Memory.java
@@ -0,0 +1,224 @@
+package util;
+
+/* Big Endian */
+
+public class Memory{
+    /* stack segment */
+    private int ss;
+
+    /* data segment */
+    private int ds;
+
+    public int esp; // adresse du sommet de la pile en octets
+    private int memSize;
+    private int dataSize;
+    private int stackSize;
+    private byte[] mem;
+
+    public Memory(int dataSize, int stackSize){
+	this.dataSize = dataSize;
+	this.stackSize = stackSize;
+	this.memSize = dataSize + stackSize;
+	mem = new byte[memSize];
+	ss = memSize - 1;
+	esp = ss;
+	ds = 0;
+    }
+
+    public void printStack(){
+	for(int adr = ss - 3; adr > esp; adr = adr - 4){
+	    System.out.print(readInt(adr) + "\t");
+	}
+	System.out.println();
+    }
+    
+    public int readInt(int address){
+	if((address < 0) || (address + 3 > ss))
+            throw new RuntimeException("segmentation fault");
+	return bytesToInt(mem[address], mem[address + 1], mem[address + 2], mem[address + 3]);
+    }
+
+   
+    public boolean readBoolean(int address){
+	if((address < 0) || (address > ss))
+            throw new RuntimeException("segmentation fault");
+	return byteToBoolean(mem[address]);
+    }
+
+    public byte readByte(int address){
+	if((address < 0) || (address > ss))
+            throw new RuntimeException("segmentation fault");
+	return mem[address];
+    }
+
+    public void writeInt(int address, int value){
+	if((address < 0) || (address + 3 > ss))
+            throw new RuntimeException("segmentation fault");
+
+	byte[] fourBytes = intToBytes(value);
+	mem[address] = fourBytes[0];
+	mem[address + 1] = fourBytes[1];
+	mem[address + 2] = fourBytes[2];
+	mem[address + 3] = fourBytes[3];
+    }
+
+    public void writeToMemory(int address, int value){
+	if((address < 0) || (address + 3 > ss))
+            throw new RuntimeException("segmentation fault");
+	
+	byte[] fourBytes = intToBytes(value);
+	mem[address] = fourBytes[0];
+	mem[address + 1] = fourBytes[1];
+	mem[address + 2] = fourBytes[2];
+	mem[address + 3] = fourBytes[3];
+    }
+
+    /*    public void writeToMemory(int address, boolean value)
+    {
+	if((address < 0) || (address > ss))
+            throw new RuntimeException("segmentation fault");
+	mem[address] = booleanToByte(value);
+	}*/
+
+
+    /* revoir c'est quoi cette affaire */
+        public int readNBytes(int address, int n){
+	//	System.out.println("read memory at address " + address);
+	if((address < 0) || (address + n - 1 > ss))
+            throw new RuntimeException("segmentation fault");
+	if(n == 1)
+	    return (int)mem[address];
+	//	if(n == 4) revoir pourquoi c'est commenté !!
+	return bytesToInt(mem[address], mem[address + 1], mem[address + 2], mem[address + 3]);
+	
+	}
+
+    /*    public void writeNBytes(int address, int value){
+	if((address < 0) || (address + n - 1 > ss))
+            throw new RuntimeException("segmentation fault");
+
+	byte[] fourBytes = intToBytes(value);
+	mem[address] = fourBytes[0];
+	mem[address + 1] = fourBytes[1];
+	mem[address + 2] = fourBytes[2];
+	mem[address + 3] = fourBytes[3];
+	}*/
+
+
+    
+       public void writeBoolean(int address, boolean value)
+    {
+	if((address < 0) || (address > ss))
+            throw new RuntimeException("segmentation fault");
+	mem[address] = booleanToByte(value);
+	}
+    
+    public void pushInt(int value){
+	if(esp - 3 < dataSize)
+            throw new RuntimeException("stack overflow");
+
+	byte[] fourBytes = intToBytes(value);
+	mem[--esp] = fourBytes[3];
+	mem[--esp] = fourBytes[2];
+	mem[--esp] = fourBytes[1];
+	mem[--esp] = fourBytes[0];
+
+
+    }
+    /*
+    public void pushBoolean(boolean value){
+	if(esp == dataSize)
+            throw new RuntimeException("stack overflow");
+	mem[esp] = booleanToByte(value);
+	esp--;
+
+	}*/
+
+    public int getTopInt(){
+	//	if(esp == ss)
+	//  throw new RuntimeException("empty stack");
+	byte byte0 = mem[esp];
+	byte byte1 = mem[esp-1];
+	byte byte2 = mem[esp-2];
+	byte byte3 = mem[esp-3];
+	return bytesToInt(byte0, byte1, byte2, byte3);
+    }
+    
+    public int popInt(){
+	if(esp + 3 >= ss)
+            throw new RuntimeException("stack underflow");
+       	byte byte0 = mem[esp++];
+	byte byte1 = mem[esp++];
+	byte byte2 = mem[esp++];
+	byte byte3 = mem[esp++];
+	
+	return bytesToInt(byte0, byte1, byte2, byte3);
+    }
+
+    /*    public boolean popBoolean()
+    {
+	if(esp == ss)
+	    throw new RuntimeException("stack underflow");
+	byte byte0 = mem[esp];
+	esp++;
+	return byteToBoolean(byte0);
+	}*/
+
+    public int bytesToInt(byte byte0, byte byte1, byte byte2, byte byte3){
+        return  ((byte0 & 0xFF) << 24) |
+                ((byte1 & 0xFF) << 16) |
+                ((byte2 & 0xFF) << 8) |
+                ((byte3 & 0xFF) << 0);
+    }
+    
+    public byte[] intToBytes2( int data ) {    
+    byte[] result = new byte[4];
+    result[0] = (byte) ((data & 0xFF000000) >> 24);
+    result[1] = (byte) ((data & 0x00FF0000) >> 16);
+    result[2] = (byte) ((data & 0x0000FF00) >> 8);
+    result[3] = (byte) ((data & 0x000000FF) >> 0);
+    return result;        
+}
+    public byte[] intToBytes(int i)
+    {
+	byte[] result = new byte[4];
+	
+	result[0] = (byte) (i >> 24);
+	result[1] = (byte) (i >> 16);
+	result[2] = (byte) (i >> 8);
+	result[3] = (byte) (i /*>> 0*/);
+	
+	return result;
+    }
+    
+    public byte booleanToByte(boolean value)
+    {
+	return (value == true)? (byte) 1 : (byte) 0; 
+	}
+
+    public boolean byteToBoolean(byte value)
+    {
+	return (value == 1)? true : false;
+    }
+
+    
+    /*        public static void main(String[] args){
+	Memory mem = new Memory(100, 100);
+	mem.pushInt(3467);
+	int v = mem.popInt();
+	System.out.println("val =" + v);
+	mem.pushInt(3468);
+	v = mem.popInt();
+	System.out.println("val =" + v);
+
+	mem.writeInt(96, 234);
+	int val = mem.readInt(96);
+	System.out.println("val =" + val);
+	
+	mem.writeInt(150, 23);
+	val = mem.readInt(250);
+	System.out.println("val =" + val);
+	
+	}*/
+    
+}
diff --git a/src/util/Type.java b/src/util/Type.java
new file mode 100644
index 0000000000000000000000000000000000000000..89e5574b53f8b046e757117b7de79748f18dc8fa
--- /dev/null
+++ b/src/util/Type.java
@@ -0,0 +1,30 @@
+package util;
+
+public enum Type{
+    NUL("nul", 0),
+    ENTIER("entier", 4),
+    BOOL("bool", 1);
+
+    private final String nom;
+    private final int taille; // taille en octets
+
+    Type(String nom, int taille){
+	this.nom = nom;
+	this.taille = taille;
+    }
+
+    public String toString(){return nom;}
+    public static Type fromString(String nom){
+	if(nom.equals("entier")){return Type.ENTIER;}
+	if(nom.equals("ENTIER")){return Type.ENTIER;}
+	if(nom.equals("bool")){return Type.BOOL;}
+	if(nom.equals("BOOL")){return Type.BOOL;}
+	if(nom.equals("nul")){return Type.NUL;}
+	if(nom.equals("NUL")){return Type.NUL;}
+	return null;
+    }
+    
+    public String nom(){return nom;}
+    public int taille(){return taille;}
+    public static boolean checkCompatibility(Type t1, Type t2){return t1 == t2;}
+}
diff --git a/src/util/graph/ColorGraph.java b/src/util/graph/ColorGraph.java
new file mode 100644
index 0000000000000000000000000000000000000000..55b867e821c8182073a421475d2ab4cb875c7215
--- /dev/null
+++ b/src/util/graph/ColorGraph.java
@@ -0,0 +1,38 @@
+package util.graph;
+
+import util.graph.*;
+import util.intset.*;
+import java.util.*;
+import java.io.*;
+
+public class ColorGraph {
+    public  Graph          graph;
+    public  int            vertexNb;
+    private Stack<Integer> stack;
+    public  IntSet         removed;
+    public  IntSet         spill;
+    public  int[]          color;
+    public  int            colorNb;
+    public  Node[]         int2Node;
+    static  int            NOCOLOR = -1;
+
+    public ColorGraph(Graph graph, int colorNb, int[] preColoredVertices){
+	this.graph   = graph;
+	this.colorNb = colorNb;
+	stack        = new Stack<Integer>(); 
+	vertexNb     = graph.nodeCount();
+	color        = new int[vertexNb];
+	removed      = new IntSet(vertexNb);
+	spill        = new IntSet(vertexNb);
+	int2Node     = graph.nodeArray();
+	for(int v=0; v < vertexNb; v++){
+	    int preColor = preColoredVertices[v];
+	    if(preColor >= 0 && preColor < colorNb)
+		color[v] = preColoredVertices[v];
+	    else
+		color[v] = NOCOLOR;
+	}
+    }
+
+
+}
diff --git a/src/util/graph/Graph.java b/src/util/graph/Graph.java
new file mode 100644
index 0000000000000000000000000000000000000000..d62bdb03239d03dc193694bfdfa32dc2063f4ef5
--- /dev/null
+++ b/src/util/graph/Graph.java
@@ -0,0 +1,83 @@
+package util.graph;
+
+public class Graph {
+
+  int nodecount=0;
+  NodeList mynodes, mylast;
+  public NodeList nodes() { return mynodes;} 
+
+  public Node newNode() {
+	return new Node(this);
+  }
+
+    void check(Node n) {
+	if (n.mygraph != this)
+	    throw new Error("Graph.addEdge using nodes from the wrong graph");
+    }
+    
+    public int nodeCount(){
+	return nodecount;
+    }
+	
+	static boolean inList(Node a, NodeList l) {
+	for(NodeList p=l; p!=null; p=p.tail)
+	    if (p.head==a) return true;
+	return false;
+    }
+
+    public Node[] nodeArray(){
+	Node[] array = new Node[nodecount];
+	for(NodeList q=mynodes; q!=null; q=q.tail) {
+	    array[q.head.mykey] = q.head;
+	}
+	return array;
+    }
+    
+
+  public void addNOEdge(Node from, Node to) {
+      check(from); check(to);
+      if (! from.goesTo(to)){
+	  to.preds=new NodeList(from, to.preds);
+	  from.succs=new NodeList(to, from.succs);
+      }
+      if (! to.goesTo(from)){
+	  from.preds=new NodeList(to, from.preds);
+	  to.succs=new NodeList(from, to.succs);
+      }
+  }
+
+  public void addEdge(Node from, Node to) {
+      check(from); check(to);
+      if (from.goesTo(to)) return;
+      to.preds=new NodeList(from, to.preds);
+      from.succs=new NodeList(to, from.succs);
+  }
+
+  NodeList delete(Node a, NodeList l) {
+	if (l==null) throw new Error("Graph.rmEdge: edge nonexistent");
+        else if (a==l.head) return l.tail;
+	else return new NodeList(l.head, delete(a, l.tail));
+  }
+
+  public void rmEdge(Node from, Node to) {
+	to.preds=delete(from,to.preds);
+        from.succs=delete(to,from.succs);
+  }
+
+ /**
+  * Print a human-readable dump for debugging.
+  */
+     public void show(java.io.PrintStream out) {
+	for (NodeList p=nodes(); p!=null; p=p.tail) {
+	  Node n = p.head;
+	  out.print(n.toString());
+	  out.print(": ");
+	  for(NodeList q=n.succ(); q!=null; q=q.tail) {
+	     out.print(q.head.toString());
+	     out.print(" ");
+	  }
+	  out.println();
+	}
+     }
+
+}
diff --git a/src/util/graph/Node.java b/src/util/graph/Node.java
new file mode 100644
index 0000000000000000000000000000000000000000..040f118b159b0597e67970eb81bd07552314307f
--- /dev/null
+++ b/src/util/graph/Node.java
@@ -0,0 +1,55 @@
+package util.graph;
+
+public class Node {
+    Graph mygraph;
+    int mykey;
+    NodeList succs;
+    NodeList preds;
+ 
+    private Node(){}
+    public Node(Graph g) {
+	mygraph=g; 
+	mykey= g.nodecount++;
+	NodeList p = new NodeList(this, null);
+	if (g.mylast==null)
+	   g.mynodes=g.mylast=p;
+	else g.mylast = g.mylast.tail = p;
+    }
+
+    public NodeList succ() {return succs;}
+    public NodeList pred() {return preds;}
+
+    public int label() {return mykey;}
+    
+    
+    NodeList cat(NodeList a, NodeList b) {
+	if (a==null) return b;
+	else return new NodeList(a.head, cat(a.tail,b));
+    }
+    public NodeList adj() {return cat(succ(), pred());}
+
+    int len(NodeList l) {
+	int i=0;
+	for(NodeList p=l; p!=null; p=p.tail) i++;
+	return i;
+    }
+
+    public int inDegree() {return len(pred());}
+    public int outDegree() {return len(succ());}
+    public int degree() {return inDegree()+outDegree();} 
+
+    public boolean goesTo(Node n) {
+	return Graph.inList(n, succ());
+    }
+
+    public boolean comesFrom(Node n) {
+	return Graph.inList(n, pred());
+    }
+
+    public boolean adj(Node n) {
+	return goesTo(n) || comesFrom(n);
+    }
+
+    public String toString() {return String.valueOf(mykey);}
+
+}
diff --git a/src/util/graph/NodeList.java b/src/util/graph/NodeList.java
new file mode 100644
index 0000000000000000000000000000000000000000..4493b7f27149154611026a78dd254d0a56b9a9ef
--- /dev/null
+++ b/src/util/graph/NodeList.java
@@ -0,0 +1,10 @@
+package util.graph;
+
+public class NodeList {
+  public Node head;
+  public NodeList tail;
+  public NodeList(Node h, NodeList t) {head=h; tail=t;}
+}
+
+
+
diff --git a/src/util/graph/TestColorGraph.java b/src/util/graph/TestColorGraph.java
new file mode 100644
index 0000000000000000000000000000000000000000..c496fae04a3ceed14608d5c57fd441662c7ead1c
--- /dev/null
+++ b/src/util/graph/TestColorGraph.java
@@ -0,0 +1,77 @@
+package util.graph;
+import util.graph.*;
+import util.intset.*;
+import java.util.*;
+import java.io.*;
+
+public class TestColorGraph
+{
+    public static void main(String[] args)
+    {
+	Graph g = new Graph();
+	/*
+	Node n0 = g.newNode();
+	Node n1 = g.newNode();
+	Node n2 = g.newNode();
+	Node n3 = g.newNode();
+	Node n4 = g.newNode();
+	
+		g.addNOEdge(n0, n1);
+	g.addNOEdge(n0, n2);
+	g.addNOEdge(n0, n3);
+       	g.addNOEdge(n0, n4);
+
+	g.addNOEdge(n1, n2);
+       	g.addNOEdge(n1, n3);
+	g.addNOEdge(n1, n4);
+
+	g.addNOEdge(n2, n3);
+	g.addNOEdge(n2, n4);
+
+	g.addNOEdge(n3, n4);
+	*/
+
+
+	Node n1 = g.newNode();
+	Node n2 = g.newNode();
+	Node n3 = g.newNode();
+	Node n4 = g.newNode();
+	Node n5 = g.newNode();
+	Node n6 = g.newNode();
+	Node n7 = g.newNode();
+	Node n8 = g.newNode();
+	Node n9 = g.newNode();
+	Node n10 = g.newNode();
+
+	g.addNOEdge(n1, n2);
+	g.addNOEdge(n1, n4);
+	g.addNOEdge(n1, n9);
+
+	g.addNOEdge(n2, n10);
+
+	g.addNOEdge(n3, n8);
+	g.addNOEdge(n3, n9);
+	g.addNOEdge(n3, n10);
+
+	g.addNOEdge(n4, n5);
+	g.addNOEdge(n4, n8);
+	g.addNOEdge(n4, n10);
+
+	g.addNOEdge(n5, n8);
+	g.addNOEdge(n5, n10);
+
+	g.addNOEdge(n6, n7);
+	g.addNOEdge(n6, n8);
+	g.addNOEdge(n6, n9);
+
+	g.addNOEdge(n7, n8);
+
+	g.addNOEdge(n8, n9);
+
+	g.show(System.out);
+	int[] colors = new int[]{ -3,-3,-3,0,-3,2,1,-3,-3,-3};
+	ColorGraph cg = new ColorGraph(g, 3, colors);
+	cg.color();
+	cg.affiche();
+    }
+}
diff --git a/src/util/intset/IntSet.java b/src/util/intset/IntSet.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d0d5f4153b2481250d3bbd514415be7aa4fabc0
--- /dev/null
+++ b/src/util/intset/IntSet.java
@@ -0,0 +1,94 @@
+package util.intset;
+
+public class IntSet{
+    private int size;
+    private boolean array[];
+    
+    public IntSet(int size){
+	this.size = size;
+	array = new boolean[size];
+	for (int i = 0; i < size; i++)
+	    array[i] = false;
+    }
+
+    public int getSize(){
+	return size;
+    }
+
+    public void empty(){
+	for (int i = 0; i < size; i++)
+	    array[i] = false;
+    }
+    
+    public boolean isMember(int elt){
+	if(elt >= size) return false;
+	return array[elt];
+    }
+
+    public boolean isEmpty(){
+	for (int i = 0; i < size; i++)
+	    if(array[i] == true)
+		return false;
+	return true;
+    }
+
+    
+    public void add(int elt){
+	if(elt >= size){
+	    System.err.println("ERROR : set is too small !!!!");
+	}
+	array[elt] = true;
+    }
+
+    public void remove(int elt){
+	if(elt >= size){
+	    System.err.println("ERROR : set is too small !!!!");
+	}
+	array[elt] = false;
+    }
+
+    public IntSet minus(IntSet s){
+	for (int i = 0; i < s.size; i++)
+	    if(s.array[i])
+		array[i] = false;
+	return this;
+    }
+
+    public IntSet copy(){
+	IntSet c = new IntSet(size);
+	for (int i = 0; i < size; i++)
+	    c.array[i] = array[i];
+	return c;
+    }
+
+    public IntSet inter(IntSet s){
+	for (int i = 0; i < s.size; i++)
+	    array[i] = array[i] && s.array[i];
+	return this;
+    }
+
+    public IntSet union(IntSet s){
+	for (int i = 0; i < s.size; i++)
+	    array[i] = array[i] || s.array[i];
+	return this;
+    }
+
+    public boolean equal(IntSet s){
+	for (int i = 0; i < s.size; i++)
+	    if(array[i] != s.array[i])
+		return false;
+	return true;
+    }
+
+    public String toString(){
+	String s = "(";
+	for (int i = 0; i < size; i++)
+	    if(array[i] == true){
+		s += i;
+		s += " ";
+	    }
+	s+= ")";
+	return s;
+    }
+    
+}
diff --git a/test/c3a-ref/add1.c3a b/test/c3a-ref/add1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..380ea2af6cfd2140bcb1faf76118f1fd83505efd
--- /dev/null
+++ b/test/c3a-ref/add1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 3 + 10
+	write @1	
+	fend
diff --git a/test/c3a-ref/add2.c3a b/test/c3a-ref/add2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..0b62ecfb4cf9cc53109d8335316e6c290188e7a4
--- /dev/null
+++ b/test/c3a-ref/add2.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 2 + 4
+	@2 = @1 + 8
+	write @2	
+	fend
diff --git a/test/c3a-ref/affect1.c3a b/test/c3a-ref/affect1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..6745f487ef8dd4fc2ae9ec137ef147540bce391e
--- /dev/null
+++ b/test/c3a-ref/affect1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	a = 1
+	write a	
+	fend
diff --git a/test/c3a-ref/affect2.c3a b/test/c3a-ref/affect2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..6745f487ef8dd4fc2ae9ec137ef147540bce391e
--- /dev/null
+++ b/test/c3a-ref/affect2.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	a = 1
+	write a	
+	fend
diff --git a/test/c3a-ref/affect3.c3a b/test/c3a-ref/affect3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..5b21472acf8c0424e83ad9843285fa9eef742642
--- /dev/null
+++ b/test/c3a-ref/affect3.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	a = 1
+	write a	
+	fend
+main	fbegin	#entree fonction
+	param 3
+	@1 = call f
+	fend
diff --git a/test/c3a-ref/and1.c3a b/test/c3a-ref/and1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..6b1e7f61f7453140e64797fc0acb79614727dcd1
--- /dev/null
+++ b/test/c3a-ref/and1.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 1
+	if 1 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/and2.c3a b/test/c3a-ref/and2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..86ec350dd5b6094683e1513a5170d6965565fd52
--- /dev/null
+++ b/test/c3a-ref/and2.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 1
+	if 0 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/and3.c3a b/test/c3a-ref/and3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..64950680bd3f32360e1b7782326e57ebe6226492
--- /dev/null
+++ b/test/c3a-ref/and3.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 == 0 goto 1
+	if 1 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/and4.c3a b/test/c3a-ref/and4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..e86a09092ade8e08d14f707e40018545af1650e9
--- /dev/null
+++ b/test/c3a-ref/and4.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 == 0 goto 1
+	if 0 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/and5.c3a b/test/c3a-ref/and5.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..df33a00f4e2c4836eaf3b214a342a3cff277f676
--- /dev/null
+++ b/test/c3a-ref/and5.c3a
@@ -0,0 +1,15 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 3
+	if 0 == 0 goto 3
+	@2 = 1
+	goto 2
+3	@2 = 0
+2	if @2 == 0 goto 1
+	if 1 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/appel-param1.c3a b/test/c3a-ref/appel-param1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..f7a67d8d470c20147b647b12c221e4fc7cc5bd50
--- /dev/null
+++ b/test/c3a-ref/appel-param1.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	write a	
+	fend
+main	fbegin	#entree fonction
+	param 1
+	@1 = call f
+	fend
diff --git a/test/c3a-ref/appel-param2.c3a b/test/c3a-ref/appel-param2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..280c4b9d9df121d436b8be92c38a089bfe58d806
--- /dev/null
+++ b/test/c3a-ref/appel-param2.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	write a	
+	write b	
+	fend
+main	fbegin	#entree fonction
+	param 1
+	param 456
+	@1 = call f
+	fend
diff --git a/test/c3a-ref/appel-param3.c3a b/test/c3a-ref/appel-param3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..68a53cf5537d53566d0ca67008c85c5033ff35d4
--- /dev/null
+++ b/test/c3a-ref/appel-param3.c3a
@@ -0,0 +1,17 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	write a	
+	write b	
+	write c	
+	write d	
+	write e	
+	fend
+main	fbegin	#entree fonction
+	param 1
+	param 2
+	param 3
+	param 4
+	param 5
+	@1 = call f
+	fend
diff --git a/test/c3a-ref/appel-retour1.c3a b/test/c3a-ref/appel-retour1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..7aac5eae2b3cf0dc62c20c43e249d9b516607398
--- /dev/null
+++ b/test/c3a-ref/appel-retour1.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	ret a
+	fend
+	fend
+main	fbegin	#entree fonction
+	param 3712
+	@1 = call f
+	write @1	
+	fend
diff --git a/test/c3a-ref/appel1.c3a b/test/c3a-ref/appel1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..1b31ff0b2403ec593d5a8ace79d3124a15f8c7f4
--- /dev/null
+++ b/test/c3a-ref/appel1.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	write 1	
+	fend
+main	fbegin	#entree fonction
+	@1 = call f
+	fend
diff --git a/test/c3a-ref/appel2.c3a b/test/c3a-ref/appel2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..5431ed3d565fada7576b75ceb75ae3145898234f
--- /dev/null
+++ b/test/c3a-ref/appel2.c3a
@@ -0,0 +1,12 @@
+	@0 = call main
+	stop @0
+g	fbegin	#entree fonction
+	write 2	
+	fend
+f	fbegin	#entree fonction
+	write 1	
+	@1 = call g
+	fend
+main	fbegin	#entree fonction
+	@2 = call f
+	fend
diff --git a/test/c3a-ref/appel3.c3a b/test/c3a-ref/appel3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..cf066d8aa5e1c75ac6b84b28a5c9cb9cc6fa1b08
--- /dev/null
+++ b/test/c3a-ref/appel3.c3a
@@ -0,0 +1,12 @@
+	@0 = call main
+	stop @0
+g	fbegin	#entree fonction
+	write 2	
+	fend
+f	fbegin	#entree fonction
+	write 1	
+	fend
+main	fbegin	#entree fonction
+	@1 = call f
+	@2 = call g
+	fend
diff --git a/test/c3a-ref/div1.c3a b/test/c3a-ref/div1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..240d4f4c5b11b570aab181dac9b71d27e55d01dd
--- /dev/null
+++ b/test/c3a-ref/div1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 4 / 2
+	write @1	
+	fend
diff --git a/test/c3a-ref/div2.c3a b/test/c3a-ref/div2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..64c4af57d97184402bf0e3dd9f4a86827b29d78a
--- /dev/null
+++ b/test/c3a-ref/div2.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 0 / 712
+	write @1	
+	fend
diff --git a/test/c3a-ref/div3.c3a b/test/c3a-ref/div3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..9275013eea5ce1f296c44219530dd361ada22660
--- /dev/null
+++ b/test/c3a-ref/div3.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 4 / 2
+	@2 = @1 / 2
+	write @2	
+	fend
diff --git a/test/c3a-ref/div4.c3a b/test/c3a-ref/div4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..37d4c267d7436397eb0d22d056d94e3b158e55eb
--- /dev/null
+++ b/test/c3a-ref/div4.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 2 / 3
+	write @1	
+	fend
diff --git a/test/c3a-ref/ecrire1.c3a b/test/c3a-ref/ecrire1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..fa9b045a3e31ad37594e80b7dc6a598762bf6be0
--- /dev/null
+++ b/test/c3a-ref/ecrire1.c3a
@@ -0,0 +1,5 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	write 3456	
+	fend
diff --git a/test/c3a-ref/ecrire2.c3a b/test/c3a-ref/ecrire2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..bab122306b675cd34e1260e9b610196adddb4d77
--- /dev/null
+++ b/test/c3a-ref/ecrire2.c3a
@@ -0,0 +1,5 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	write 0	
+	fend
diff --git a/test/c3a-ref/egal1.c3a b/test/c3a-ref/egal1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..8284ba64809b1c7e35b7be49177ab5bee7a50e3e
--- /dev/null
+++ b/test/c3a-ref/egal1.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 123 == 123 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/egal2.c3a b/test/c3a-ref/egal2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..13efbcddb9086f97a2df4630d080310327f8b494
--- /dev/null
+++ b/test/c3a-ref/egal2.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 412 == 34 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/egal3.c3a b/test/c3a-ref/egal3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..e17359701865d885c36d22442ac2cc07c0b6466e
--- /dev/null
+++ b/test/c3a-ref/egal3.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 1
+	if 2 == 2 goto 1
+	@2 = 0
+1	@1 = 1
+	if @2 == 1 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/err5.c3a b/test/c3a-ref/err5.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..4f8b67f8dfb78a87aef134850bbe13e5822a22e8
--- /dev/null
+++ b/test/c3a-ref/err5.c3a
@@ -0,0 +1,7 @@
+f	fbegin	#entree fonction
+	write 1	
+	fend
+main	fbegin	#entree fonction
+	t0 = call f
+	f = t0
+	fend
diff --git a/test/c3a-ref/fibo.c3a b/test/c3a-ref/fibo.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..a67a5259d751fa02376cc809d14a249698da7adc
--- /dev/null
+++ b/test/c3a-ref/fibo.c3a
@@ -0,0 +1,25 @@
+	@0 = call main
+	stop @0
+fibo	fbegin	#entree fonction
+	@1 = 1
+	if n < 2 goto 2
+	@1 = 0
+2	if @1 == 0 goto 0
+	ret 1
+	fend
+	goto 1
+0	@3 = n - 1
+	param @3
+	@2 = call fibo
+	@5 = n - 2
+	param @5
+	@4 = call fibo
+	@6 = @2 + @4
+	ret @6
+	fend
+1	fend
+main	fbegin	#entree fonction
+	param 9
+	@7 = call fibo
+	write @7	
+	fend
diff --git a/test/c3a-ref/inf1.c3a b/test/c3a-ref/inf1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..2d1a31310a7e2afddb23f995fbba8c913a9a4036
--- /dev/null
+++ b/test/c3a-ref/inf1.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 3 < 3 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/inf2.c3a b/test/c3a-ref/inf2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..de2ab0f59d08a318e6322e9e6230b2f13c592896
--- /dev/null
+++ b/test/c3a-ref/inf2.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 4 < 1 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/inf3.c3a b/test/c3a-ref/inf3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..83499a0caaab4dd86e77593a26acf228ea9e7d36
--- /dev/null
+++ b/test/c3a-ref/inf3.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 312 < 475 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/inf4.c3a b/test/c3a-ref/inf4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..98e7d238d171f15c9ea9dc6d30fa3132b2478db6
--- /dev/null
+++ b/test/c3a-ref/inf4.c3a
@@ -0,0 +1,11 @@
+	t0 = call main
+	stop t0
+main	fbegin	#entree fonction
+	t2 = 1
+	if 3 < 2 goto l1
+	t2 = 0
+l1	t1 = 1
+	if t2 < 1 goto l0
+	t1 = 0
+l0	write t1	
+	fend
diff --git a/test/c3a-ref/mult1.c3a b/test/c3a-ref/mult1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..34d20ee1c8fb848656ab00644d72aae42435f04a
--- /dev/null
+++ b/test/c3a-ref/mult1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 2 * 3
+	write @1	
+	fend
diff --git a/test/c3a-ref/mult2.c3a b/test/c3a-ref/mult2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..78089fe057148b93ca78fd3bb565bf09fea3f70c
--- /dev/null
+++ b/test/c3a-ref/mult2.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 0 * 321
+	write @1	
+	fend
diff --git a/test/c3a-ref/mult3.c3a b/test/c3a-ref/mult3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..b28dfa91f5b5bad837e5d5a788a1546123cfc9e1
--- /dev/null
+++ b/test/c3a-ref/mult3.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 3 * 3
+	@2 = @1 * 2
+	write @2	
+	fend
diff --git a/test/c3a-ref/not1.c3a b/test/c3a-ref/not1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..991e63eec9769a2956742bafe796c528c0ae10f5
--- /dev/null
+++ b/test/c3a-ref/not1.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 1 == 0 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/not2.c3a b/test/c3a-ref/not2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..482f3d5844622d223fa8ddbae671866fa9369c1f
--- /dev/null
+++ b/test/c3a-ref/not2.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 1
+	if 0 == 0 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/not3.c3a b/test/c3a-ref/not3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c0800ee00493c9539abb93ea542db6cc67eb5712
--- /dev/null
+++ b/test/c3a-ref/not3.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 1
+	if 0 == 0 goto 1
+	@2 = 0
+1	@1 = 1
+	if @2 == 0 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/or1.c3a b/test/c3a-ref/or1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..844f198a06f4494ba75f96d77baaf97060b0a35b
--- /dev/null
+++ b/test/c3a-ref/or1.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 != 0 goto 1
+	if 1 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/or2.c3a b/test/c3a-ref/or2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..894e598268c84cca18eb0d863e39c948a65442c4
--- /dev/null
+++ b/test/c3a-ref/or2.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 != 0 goto 1
+	if 0 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/or3.c3a b/test/c3a-ref/or3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..08ea85aa6d94c2a5dfe94c103eba494339f8aeba
--- /dev/null
+++ b/test/c3a-ref/or3.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 != 0 goto 1
+	if 1 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/or4.c3a b/test/c3a-ref/or4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..dfe6660d1aa7f934d977a86f863ba518eb64437f
--- /dev/null
+++ b/test/c3a-ref/or4.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 != 0 goto 1
+	if 0 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/or5.c3a b/test/c3a-ref/or5.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c7fae5b38c326be24b53af91b2882a07b95cfeb2
--- /dev/null
+++ b/test/c3a-ref/or5.c3a
@@ -0,0 +1,15 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 != 0 goto 3
+	if 1 != 0 goto 3
+	@2 = 0
+	goto 2
+3	@2 = 1
+2	if @2 != 0 goto 1
+	if 0 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/parenth1.c3a b/test/c3a-ref/parenth1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..3cdcdf510ef3e817d53050b59f2954bdb1537b79
--- /dev/null
+++ b/test/c3a-ref/parenth1.c3a
@@ -0,0 +1,5 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	write 1	
+	fend
diff --git a/test/c3a-ref/parenth2.c3a b/test/c3a-ref/parenth2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..ebfa3df44a1db8b187ce403d33e373c839aff8d9
--- /dev/null
+++ b/test/c3a-ref/parenth2.c3a
@@ -0,0 +1,5 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	write 2	
+	fend
diff --git a/test/c3a-ref/prio23-1.c3a b/test/c3a-ref/prio23-1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..9b257f034be5f9a65aeea390a534ba3ecc2937e9
--- /dev/null
+++ b/test/c3a-ref/prio23-1.c3a
@@ -0,0 +1,9 @@
+	t0 = call main
+	stop t0
+main	fbegin	#entree fonction
+	t1 = 1
+	if 0 = 0 goto l0
+	t1 = 0
+l0	t2 = t1 * 10
+	write t2	
+	fend
diff --git a/test/c3a-ref/prio23-2.c3a b/test/c3a-ref/prio23-2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c675df7d6312b90e763dd5de2e3ea3846637d9e5
--- /dev/null
+++ b/test/c3a-ref/prio23-2.c3a
@@ -0,0 +1,9 @@
+	t0 = call main
+	stop t0
+main	fbegin	#entree fonction
+	t1 = 1
+	if 10 = 0 goto l0
+	t1 = 0
+l0	t2 = 3 * t1
+	write t2	
+	fend
diff --git a/test/c3a-ref/prio23-3.c3a b/test/c3a-ref/prio23-3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..00a6d37b205203cb82f426fa64d27f7a11b06023
--- /dev/null
+++ b/test/c3a-ref/prio23-3.c3a
@@ -0,0 +1,9 @@
+	t0 = call main
+	stop t0
+main	fbegin	#entree fonction
+	t1 = 1
+	if 0 = 0 goto l0
+	t1 = 0
+l0	t2 = t1 / 1
+	write t2	
+	fend
diff --git a/test/c3a-ref/prio23-4.c3a b/test/c3a-ref/prio23-4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..ac5ed732a4852c95d66de10c879e2029986902c9
--- /dev/null
+++ b/test/c3a-ref/prio23-4.c3a
@@ -0,0 +1,12 @@
+	t0 = call main
+	stop t0
+main	fbegin	#entree fonction
+	t1 = 1
+	if 1 = 0 goto l0
+	t1 = 0
+l0	t2 = 1
+	if 0 = 0 goto l1
+	t2 = 0
+l1	t3 = t1 / t2
+	write t3	
+	fend
diff --git a/test/c3a-ref/prio34-1.c3a b/test/c3a-ref/prio34-1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..bf1aae0eccb51f1010e937e3dc020bf1b13926bc
--- /dev/null
+++ b/test/c3a-ref/prio34-1.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 3 * 4
+	@2 = 2 + @1
+	write @2	
+	fend
diff --git a/test/c3a-ref/prio34-2.c3a b/test/c3a-ref/prio34-2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..599e604a702eaa13edaa1e7204a5c3a56bea5d2a
--- /dev/null
+++ b/test/c3a-ref/prio34-2.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 2 * 3
+	@2 = @1 - 4
+	write @2	
+	fend
diff --git a/test/c3a-ref/prio34-3.c3a b/test/c3a-ref/prio34-3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..21ac788824d92e8cda4535e56a5106c35687f508
--- /dev/null
+++ b/test/c3a-ref/prio34-3.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 6 / 3
+	@2 = @1 - 72
+	write @2	
+	fend
diff --git a/test/c3a-ref/prio34-4.c3a b/test/c3a-ref/prio34-4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..5b08bc8575718d00eb5369f18ac7f87bf84ca876
--- /dev/null
+++ b/test/c3a-ref/prio34-4.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 20 / 10
+	@2 = 6 + @1
+	write @2	
+	fend
diff --git a/test/c3a-ref/prio45-1.c3a b/test/c3a-ref/prio45-1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..66f66e7f650a865ab5afd846e392db0e920db942
--- /dev/null
+++ b/test/c3a-ref/prio45-1.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 0 + 1
+	@1 = 1
+	if 2 == @2 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio45-2.c3a b/test/c3a-ref/prio45-2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..194117811cc3fd6a710c5a47095d23779cd5204b
--- /dev/null
+++ b/test/c3a-ref/prio45-2.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 1 + 234
+	@1 = 1
+	if @2 == 1 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio45-3.c3a b/test/c3a-ref/prio45-3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..71e45e255e4bc70e98eb5e3440af00ab2578de58
--- /dev/null
+++ b/test/c3a-ref/prio45-3.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 11 + 100
+	@1 = 1
+	if 12 < @2 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio45-4.c3a b/test/c3a-ref/prio45-4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..0b01672699919e70cc14e23035c3666edd8c0d64
--- /dev/null
+++ b/test/c3a-ref/prio45-4.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 21 - 21
+	@1 = 1
+	if @2 < 1 goto 0
+	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio56-1.c3a b/test/c3a-ref/prio56-1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..683b54f60e6ca226c98f68606ed290091fabede8
--- /dev/null
+++ b/test/c3a-ref/prio56-1.c3a
@@ -0,0 +1,13 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 1
+	if 1 == 2 goto 2
+	@2 = 0
+2	if @2 == 0 goto 1
+	if 1 == 0 goto 1
+	@1 = 1
+	goto 0
+1	@1 = 0
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio56-2.c3a b/test/c3a-ref/prio56-2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..e9c62a78009bae3f9dda9511fc7c57b5aca21fad
--- /dev/null
+++ b/test/c3a-ref/prio56-2.c3a
@@ -0,0 +1,13 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@2 = 1
+	if 0 == 1 goto 2
+	@2 = 0
+2	if 1 != 0 goto 1
+	if @2 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio67-1.c3a b/test/c3a-ref/prio67-1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..ce8a86ee5c20b555f99cab09259ab143aa67cad9
--- /dev/null
+++ b/test/c3a-ref/prio67-1.c3a
@@ -0,0 +1,15 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 == 0 goto 3
+	if 1 == 0 goto 3
+	@2 = 1
+	goto 2
+3	@2 = 0
+2	if @2 != 0 goto 1
+	if 1 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/prio67-2.c3a b/test/c3a-ref/prio67-2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..684cec0adbee26c3ba96575c47c4db1011faad77
--- /dev/null
+++ b/test/c3a-ref/prio67-2.c3a
@@ -0,0 +1,15 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 3
+	if 0 == 0 goto 3
+	@2 = 1
+	goto 2
+3	@2 = 0
+2	if 1 != 0 goto 1
+	if @2 != 0 goto 1
+	@1 = 0
+	goto 0
+1	@1 = 1
+0	write @1	
+	fend
diff --git a/test/c3a-ref/rec1.c3a b/test/c3a-ref/rec1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..322131ac9406cc9562f72d8798e1328a0c0c26cd
--- /dev/null
+++ b/test/c3a-ref/rec1.c3a
@@ -0,0 +1,22 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	@1 = 1
+	if a == 1 goto 2
+	@1 = 0
+2	if @1 == 0 goto 0
+	ret 1
+	fend
+	goto 1
+0	@3 = a - 1
+	param @3
+	@2 = call f
+	@4 = 1 + @2
+	ret @4
+	fend
+1	fend
+main	fbegin	#entree fonction
+	param 100
+	@5 = call f
+	write @5	
+	fend
diff --git a/test/c3a-ref/si1.c3a b/test/c3a-ref/si1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..fc0a9277972a7f6dfce324e08e772f38d8c8ec7f
--- /dev/null
+++ b/test/c3a-ref/si1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 1
+	write 1	
+1	fend
diff --git a/test/c3a-ref/si2.c3a b/test/c3a-ref/si2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..3bc635d4082a09bbc218553f9fc742a4ecd79da9
--- /dev/null
+++ b/test/c3a-ref/si2.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 == 0 goto 0
+	write 1	
+	goto 1
+0	write 0	
+1	fend
diff --git a/test/c3a-ref/si3.c3a b/test/c3a-ref/si3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..77f57ae4440addc24f849be6a74dd86883491f7b
--- /dev/null
+++ b/test/c3a-ref/si3.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 0
+	write 1	
+	goto 1
+0	write 0	
+1	write 1	
+	fend
diff --git a/test/c3a-ref/si4.c3a b/test/c3a-ref/si4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..48200340dab475a5354d6832db190c1e8242fb0c
--- /dev/null
+++ b/test/c3a-ref/si4.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 0 == 0 goto 0
+	write 1	
+	goto 1
+0	write 0	
+1	write 1	
+	fend
diff --git a/test/c3a-ref/si5.c3a b/test/c3a-ref/si5.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..0b8d4f22a6e43890cab91f74be1381f4f21aac84
--- /dev/null
+++ b/test/c3a-ref/si5.c3a
@@ -0,0 +1,9 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	if 1 == 0 goto 3
+	write 1	
+	if 1 == 0 goto 3
+	write 1	
+3	write 1	
+	fend
diff --git a/test/c3a-ref/sub1.c3a b/test/c3a-ref/sub1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..1b0e46f521b7dd9f3f7538c3409bcc981ea3ca03
--- /dev/null
+++ b/test/c3a-ref/sub1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 10 - 5
+	write @1	
+	fend
diff --git a/test/c3a-ref/sub2.c3a b/test/c3a-ref/sub2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..e4899730592e03554d3cd8737fee608259c1ddd6
--- /dev/null
+++ b/test/c3a-ref/sub2.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 7 - 20
+	write @1	
+	fend
diff --git a/test/c3a-ref/sub3.c3a b/test/c3a-ref/sub3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..7ccf2bf30f0dd1bea0290b157f321e8c0c123c56
--- /dev/null
+++ b/test/c3a-ref/sub3.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	@1 = 2 - 1
+	@2 = @1 - 1
+	write @2	
+	fend
diff --git a/test/c3a-ref/tab1.c3a b/test/c3a-ref/tab1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..453f47238ae6ce5088f0da724298466425dacfce
--- /dev/null
+++ b/test/c3a-ref/tab1.c3a
@@ -0,0 +1,10 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	tab[0] = 0
+	tab[1] = 1
+	tab[2] = 2
+	write tab[0]	
+	write tab[1]	
+	write tab[2]	
+	fend
diff --git a/test/c3a-ref/tab2.c3a b/test/c3a-ref/tab2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..db4c77a3e13a4a31c3e30c645ffb97f475704381
--- /dev/null
+++ b/test/c3a-ref/tab2.c3a
@@ -0,0 +1,14 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	base = 2
+	@1 = base + 0
+	tab[@1] = 34
+	@2 = base + 1
+	tab[@2] = 74
+	@3 = base + 2
+	tab[@3] = 16
+	write tab[2]	
+	write tab[3]	
+	write tab[4]	
+	fend
diff --git a/test/c3a-ref/tab3.c3a b/test/c3a-ref/tab3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..2483abb4aef86e62611fe5c7136d174ad75e6a25
--- /dev/null
+++ b/test/c3a-ref/tab3.c3a
@@ -0,0 +1,17 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	base = 2
+	offset = 0
+	@1 = base + offset
+	tab[@1] = 34
+	offset = 1
+	@2 = base + offset
+	tab[@2] = 74
+	offset = 2
+	@3 = base + offset
+	tab[@3] = 16
+	write tab[2]	
+	write tab[3]	
+	write tab[4]	
+	fend
diff --git a/test/c3a-ref/tab4.c3a b/test/c3a-ref/tab4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..1613664598935700ec7afd0d7c0e3db6374d25e2
--- /dev/null
+++ b/test/c3a-ref/tab4.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	tab[0] = 1
+	tab[tab[0]] = 12
+	@1 = tab[0] + 1
+	tab[@1] = 13
+	write tab[0]	
+	write tab[1]	
+	write tab[2]	
+	fend
diff --git a/test/c3a-ref/tantque1.c3a b/test/c3a-ref/tantque1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..78d3f86ed196912bcae10b1dd05610142cb4c377
--- /dev/null
+++ b/test/c3a-ref/tantque1.c3a
@@ -0,0 +1,14 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	a = 10
+0	@1 = 1
+	if 0 < a goto 2
+	@1 = 0
+2	if @1 == 0 goto 1
+	write a	
+	@2 = a - 1
+	a = @2
+	goto 0
+1	write 0	
+	fend
diff --git a/test/c3a-ref/tantque2.c3a b/test/c3a-ref/tantque2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..3adbfa490ac4671c48e06487d5c38e68d765b0b8
--- /dev/null
+++ b/test/c3a-ref/tantque2.c3a
@@ -0,0 +1,22 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	a = 0
+0	@1 = 1
+	if a < 4 goto 2
+	@1 = 0
+2	if @1 == 0 goto 1
+	b = 0
+3	@2 = 1
+	if b < 4 goto 5
+	@2 = 0
+5	if @2 == 0 goto 4
+	write a	
+	write b	
+	@3 = b + 1
+	b = @3
+	goto 3
+4	@4 = a + 1
+	a = @4
+	goto 0
+1	fend
diff --git a/test/c3a-ref/tri.c3a b/test/c3a-ref/tri.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..f1052ff30ba56e7a28323050217219a85f3e92ca
--- /dev/null
+++ b/test/c3a-ref/tri.c3a
@@ -0,0 +1,71 @@
+	@0 = call main
+	stop @0
+initialiser	fbegin	#entree fonction
+	tab[0] = 8
+	tab[1] = 6
+	tab[2] = 9
+	tab[3] = 9
+	tab[4] = 4
+	tab[5] = 2
+	tab[6] = 3
+	tab[7] = 1
+	tab[8] = 4
+	tab[9] = 5
+	fend
+afficher	fbegin	#entree fonction
+	i = 0
+0	@1 = 1
+	if i < n goto 2
+	@1 = 0
+2	if @1 == 0 goto 1
+	write tab[i]	
+	@2 = i + 1
+	i = @2
+	goto 0
+1	write 0	
+	fend
+echanger	fbegin	#entree fonction
+	temp = tab[j]
+	tab[j] = tab[i]
+	tab[i] = temp
+	fend
+trier	fbegin	#entree fonction
+	m = n
+	echange = 1
+3	@3 = 1
+	if echange == 1 goto 5
+	@3 = 0
+5	if @3 == 0 goto 4
+	echange = 0
+	j = 0
+6	@5 = m - 1
+	@4 = 1
+	if j < @5 goto 8
+	@4 = 0
+8	if @4 == 0 goto 7
+	@7 = j + 1
+	@6 = 1
+	if tab[@7] < tab[j] goto 11
+	@6 = 0
+11	if @6 == 0 goto 10
+	param j
+	@9 = j + 1
+	param @9
+	@8 = call echanger
+	echange = 1
+10	@10 = j + 1
+	j = @10
+	goto 6
+7	@11 = m - 1
+	m = @11
+	goto 3
+4	fend
+main	fbegin	#entree fonction
+	@12 = call initialiser
+	param 10
+	@13 = call afficher
+	param 10
+	@14 = call trier
+	param 10
+	@15 = call afficher
+	fend
diff --git a/test/c3a-ref/varglob1.c3a b/test/c3a-ref/varglob1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c681ada75f67040a6948b8e79e5eb5fcd31e75c9
--- /dev/null
+++ b/test/c3a-ref/varglob1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	variable = 6834
+	write variable	
+	fend
diff --git a/test/c3a-ref/varglob2.c3a b/test/c3a-ref/varglob2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..bdaee5047b6ffbef66e24800560520cea008267a
--- /dev/null
+++ b/test/c3a-ref/varglob2.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	variable = 10
+	@1 = variable + 50
+	write @1	
+	fend
diff --git a/test/c3a-ref/varglob3.c3a b/test/c3a-ref/varglob3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..eb8ce562ce5c4b5c5f3d0eeab1c691b9de909712
--- /dev/null
+++ b/test/c3a-ref/varglob3.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	var1 = 10
+	var2 = 34
+	write var1	
+	write var2	
+	fend
diff --git a/test/c3a-ref/varglob4.c3a b/test/c3a-ref/varglob4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c5b8635e8068130a9410e7995a82fca82e4ccff4
--- /dev/null
+++ b/test/c3a-ref/varglob4.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	var1 = 10
+	var2 = 34
+	@1 = var1 + var2
+	write @1	
+	fend
diff --git a/test/c3a-ref/varloc1.c3a b/test/c3a-ref/varloc1.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..c681ada75f67040a6948b8e79e5eb5fcd31e75c9
--- /dev/null
+++ b/test/c3a-ref/varloc1.c3a
@@ -0,0 +1,6 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	variable = 6834
+	write variable	
+	fend
diff --git a/test/c3a-ref/varloc2.c3a b/test/c3a-ref/varloc2.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..bdaee5047b6ffbef66e24800560520cea008267a
--- /dev/null
+++ b/test/c3a-ref/varloc2.c3a
@@ -0,0 +1,7 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	variable = 10
+	@1 = variable + 50
+	write @1	
+	fend
diff --git a/test/c3a-ref/varloc3.c3a b/test/c3a-ref/varloc3.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..7dbbadb8d617aaef09863c28279e5c77cef6955e
--- /dev/null
+++ b/test/c3a-ref/varloc3.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	var1 = 10
+	var2 = 30
+	write var1	
+	write var2	
+	fend
diff --git a/test/c3a-ref/varloc4.c3a b/test/c3a-ref/varloc4.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..71e8be70dfed719b17f12563e193ca461d575e7a
--- /dev/null
+++ b/test/c3a-ref/varloc4.c3a
@@ -0,0 +1,8 @@
+	@0 = call main
+	stop @0
+main	fbegin	#entree fonction
+	var1 = 10
+	var2 = 30
+	@1 = var1 + var2
+	write @1	
+	fend
diff --git a/test/c3a-ref/varloc5.c3a b/test/c3a-ref/varloc5.c3a
new file mode 100644
index 0000000000000000000000000000000000000000..3c183068932e6094ec7b19c960dc777fa68b7c13
--- /dev/null
+++ b/test/c3a-ref/varloc5.c3a
@@ -0,0 +1,11 @@
+	@0 = call main
+	stop @0
+f	fbegin	#entree fonction
+	var1 = 10
+	write var1	
+	fend
+main	fbegin	#entree fonction
+	var1 = 20
+	@1 = call f
+	write var1	
+	fend
diff --git a/test/evaluate.py b/test/evaluate.py
new file mode 100755
index 0000000000000000000000000000000000000000..febaaf25b8cfd221f36fb690f76da55d10ae42ab
--- /dev/null
+++ b/test/evaluate.py
@@ -0,0 +1,473 @@
+#! /usr/bin/python3 -u
+
+import sys
+import os
+import subprocess
+import inspect
+import argparse
+
+# code de sortie du compilateur
+
+NOERROR_CODE = 0
+ERR_TYPE_CODE = 3
+ERR_SYMBOL_TABLE_CODE = 4
+ERR_SYNTAX_CODE = 5
+ERR_LEX_CODE = 6
+
+# coefficients pour le calcul de la note finale
+SC_COEFF = 4
+SA_DIFF_COEFF = 0
+TS_DIFF_COEFF = 0
+SA_COEFF = 3
+C3A_DIFF_COEFF = 0
+C3A_COEFF = 3
+PRE_NASM_DIFF = 0
+PRE_NASM_COEFF = 3
+NASM_DIFF_COEFF = 0
+NASM_COEFF = 3
+EXE_COEFF = 0
+ERR_TS_COEFF = 2
+ERR_TYPE_COEFF = 2
+
+# Paths relative to this file (evaluate.py)
+inputPath = "./input/"
+errInputPathTs = "./input_err_ts/"
+errInputPathType = "./input_err_type/"
+refPath = "./"
+srcPath = "../src/"
+# Keep empty
+classpath = ""
+# Outputs files (don't change this, it's set in the main)
+outErr = sys.stderr
+outScore = sys.stdout
+outVerbose = open(os.devnull,"w")
+outputFilename = "result.txt"
+
+################################################################################
+def compileCompiler() :
+  global classpath
+  for file in ["Compiler.java", "SaVM.java", "C3aVM.java", "NasmVM.java"] :
+    if not os.path.isfile(srcPath+file) :
+      print("Skipping compilation of %s"%file, file=outVerbose)
+      continue
+    package = file.lower().split('.')[0].replace('vm', '')
+    if package in ["c3a", "nasm"] and not os.path.isdir(srcPath+package) :
+      print("Skipping compilation of %s"%file, file=outVerbose)
+      continue
+    print("Compiling %s..."%file, end="", file=outVerbose)
+    proc = subprocess.Popen("cd %s && javac %s %s %s"%(srcPath, "-cp " if len(classpath) > 0 else "", classpath, file), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    errMess = proc.stderr.read().decode('utf8')
+    returnCode = proc.wait()
+    if returnCode == 0 :
+      print("Done", file=outVerbose)
+    else :
+      print("", file=outVerbose)
+      print("ERROR !", file=outErr)
+      print(errMess, file=outErr)
+      exit(1)
+    print("", file=outVerbose)
+    classpath = "../xerces-2_12_1/*:%s"%srcPath
+  classpath = ""
+################################################################################
+
+################################################################################
+def deleteClasses() :
+
+  for root, subdirs, files in os.walk("%s.."%srcPath) :
+    if ".git" in root :
+      continue
+    for filename in files :
+      if os.path.splitext(filename)[1] == ".class" :
+        os.remove(root+"/"+filename)
+        
+  return classpath
+################################################################################
+
+################################################################################
+def findClasspath() :
+  global classpath
+
+  if len(classpath) > 0 :
+    return classpath
+
+  for root, subdirs, files in os.walk("%s.."%srcPath) :
+    if ".git" in root :
+      continue
+    for filename in files :
+      if os.path.splitext(filename)[1] in [".class", ".jar"] :
+        classpath += ("" if len(classpath) == 0 else ":") + root
+        break
+
+  classpath += ("" if len(classpath) == 0 else ":")+"../xerces-2_12_1/*"
+  return classpath
+################################################################################
+
+################################################################################
+def compiler(verbose="-v 2") :
+  return "java -classpath %s Compiler %s"%(findClasspath(), verbose)
+################################################################################
+
+################################################################################
+def green(string) :
+  return "\033[92m%s\033[0m"%string
+################################################################################
+
+################################################################################
+def purple(string) :
+  return "\033[95m%s\033[0m"%string
+################################################################################
+
+################################################################################
+def red(string) :
+  return "\033[91m%s\033[0m"%string
+################################################################################
+
+################################################################################
+def changeExtension(filename, newExtension) :
+  return os.path.splitext(filename)[0] + newExtension
+################################################################################
+
+################################################################################
+def findInputFiles(path) :
+  inputFiles = []
+  for filename in os.listdir(path) :
+    if os.path.splitext(filename)[1] == ".l" :
+      inputFiles.append(filename)
+  inputFiles.sort()
+  return inputFiles
+################################################################################
+
+################################################################################
+def deleteCompilationOutputs() :
+  outputExtensions = [".exe", ".exeout", ".o", ".out", ".sa", ".saout", ".sc", ".ts", ".nasm", ".nasmout", ".pre-nasm", ".pre-nasmout", ".c3a", ".c3aout", ".fg", ".fgs", ".ig"]
+  for filename in os.listdir(inputPath) :
+    if os.path.splitext(filename)[1] in outputExtensions :
+      os.remove(inputPath+filename)
+################################################################################
+
+################################################################################
+def compileInputFiles(inputFiles) :
+  evaluation = getNewEvaluationResult(ERR_SYNTAX_CODE)
+  for inputFile in inputFiles :
+    lightFilename = inputFile.split("/")[-1]
+    print("Compiling %s..."%inputFile, file=outVerbose, flush=True, end='')
+    returnCode = subprocess.Popen("{} {}{}".format(compiler(), inputPath, inputFile), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).wait()
+    if returnCode == NOERROR_CODE :
+      evaluation[1]["correct"].append(lightFilename)
+      print("Done", file=outVerbose)
+    else :
+      evaluation[1]["incorrect"].append(lightFilename)
+      print("ERROR !", file=outErr)
+  print("", file=outVerbose)
+  return evaluation
+################################################################################
+
+################################################################################
+def getNewEvaluationResult(name) :
+  return [name, {"correct" : [], "incorrect" : [], "notfound" : []}]
+################################################################################
+
+################################################################################
+def evaluateCompilationErrors(inputFiles, expectedCode, name) :
+  evaluation = getNewEvaluationResult(name)
+
+  print(file=outVerbose)
+
+  for inputFile in inputFiles :
+    if not os.path.isfile(inputFile) :
+      print("ERROR : could not find '%s'"%inputFile, file=outErr)
+      exit(1)
+    lightFilename = inputFile.split("/")[-1]
+    print("Compiling %s..."%lightFilename, end="", file=outVerbose)
+    returnCode = subprocess.Popen("{} {}".format(compiler(verbose=""), inputFile), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).wait()
+    print("Done (%d)"%returnCode, file=outVerbose)
+    if returnCode == expectedCode :
+      evaluation[1]["correct"].append(lightFilename)
+    else :
+      evaluation[1]["incorrect"].append(lightFilename)
+  print("", file=outVerbose)
+
+  return evaluation
+################################################################################
+
+################################################################################
+def evaluateDiff(inputFiles, extension, extensionRef, path, name) :
+  evaluation = getNewEvaluationResult(name)
+
+  for filename in inputFiles :
+    producedFile = changeExtension(filename, extension)
+    if not os.path.isfile(inputPath+producedFile) :
+      evaluation[1]["notfound"].append(producedFile)
+      continue
+    
+    ref = refPath+path+changeExtension(producedFile, extensionRef)
+    if not os.path.isfile(ref) :
+      print("ATTENTION : Fichier non trouvé : %s"%ref, file=sys.stderr)
+      continue
+
+    refContent = []
+    for line in open(ref, "r") :
+      line = line.strip()
+      if len(line) > 0 :
+        refContent.append(line)
+    producedContent = []
+    for line in open(inputPath+producedFile, "r") :
+      line = line.strip()
+      if len(line) > 0 :
+        producedContent.append(line)
+
+    if producedContent == refContent :
+      evaluation[1]["correct"].append(producedFile)
+    else :
+      evaluation[1]["incorrect"].append(producedFile)
+
+  return evaluation
+################################################################################
+
+################################################################################
+def evaluateSa(inputFiles) :
+  errs = []
+  for filename in inputFiles :
+    saFilename = inputPath+changeExtension(filename, ".sa")
+    outFilename = inputPath+changeExtension(filename, ".saout")
+    if not os.path.isfile(saFilename) :
+      continue
+
+    command = "java -classpath %s SaVM -sa %s > %s"%(findClasspath(), saFilename, outFilename)
+    out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode()
+    if len(out) != 0 :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+
+  return evaluateDiff(inputFiles, ".saout", ".out", "out-ref/", "Execution de sa"), errs
+################################################################################
+
+################################################################################
+def evaluateC3a(inputFiles) :
+  errs = []
+  for filename in inputFiles :
+    c3aFilename = inputPath+changeExtension(filename, ".c3a")
+    tsFilename = inputPath+changeExtension(filename, ".ts")
+    outFilename = inputPath+changeExtension(filename, ".c3aout")
+    if not os.path.isfile(c3aFilename) or not os.path.isfile(tsFilename) :
+      continue
+
+    command = "java -classpath %s C3aVM -c3a %s -ts %s > %s"%(findClasspath(), c3aFilename, tsFilename, outFilename)
+    out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode()
+    if len(out) != 0 :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+
+  return evaluateDiff(inputFiles, ".c3aout", ".out", "out-ref/", "Execution du c3a"), errs
+################################################################################
+
+################################################################################
+def evaluatePreNasm(inputFiles) :
+  errs = []
+  for filename in inputFiles :
+    nasmFilename = inputPath+changeExtension(filename, ".pre-nasm")
+    outFilename = inputPath+changeExtension(filename, ".pre-nasmout")
+    if not os.path.isfile(nasmFilename) :
+      continue
+
+    command = "java -classpath %s NasmVM -nasm %s > %s"%(findClasspath(), nasmFilename, outFilename)
+    out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode()
+    if len(out) != 0 :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+
+  return evaluateDiff(inputFiles, ".pre-nasmout", ".out", "out-ref/", "Execution du pre-nasm"), errs
+################################################################################
+
+################################################################################
+def evaluateNasm(inputFiles) :
+  errs = []
+  for filename in inputFiles :
+    nasmFilename = inputPath+changeExtension(filename, ".nasm")
+    outFilename = inputPath+changeExtension(filename, ".nasmout")
+    if not os.path.isfile(nasmFilename) :
+      continue
+
+    command = "java -classpath %s NasmVM -nasm %s > %s"%(findClasspath(), nasmFilename, outFilename)
+    out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode()
+    if len(out) != 0 :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+
+  return evaluateDiff(inputFiles, ".nasmout", ".out", "out-ref/", "Execution du nasm"), errs
+################################################################################
+
+################################################################################
+def evaluateExecutable(inputFiles) :
+  errs = []
+  for filename in inputFiles :
+    nasmFilename = changeExtension(filename, ".nasm")
+    objectFilename = changeExtension(filename, ".o")
+    execFilename = changeExtension(filename, ".exe")
+    outFilename = changeExtension(filename, ".exeout")
+    if not os.path.isfile(inputPath+nasmFilename) :
+      continue
+
+    out = subprocess.Popen("cd {} && nasm -f elf -dwarf -g {}".format(inputPath+"..","input/"+nasmFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read()
+    if not os.path.isfile(inputPath+objectFilename) :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+      continue
+    out = subprocess.Popen("ld -m elf_i386 -o {}{} {}{}".format(inputPath,execFilename,inputPath,objectFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read()
+    if not os.path.isfile(inputPath+execFilename) :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+      continue
+    out = subprocess.Popen("{}{} > {}{}".format(inputPath,execFilename,inputPath,outFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read()
+    if not os.path.isfile(inputPath+outFilename) :
+      errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out))
+      continue
+
+  return evaluateDiff(inputFiles, ".exeout", ".out", "out-ref/", "Execution du binaire"), errs
+################################################################################
+
+################################################################################
+def printListElements(destination, elements, colorFunction, useColor, resultStr) :
+  if len(elements) == 0 :
+    return
+  maxColumnSize = len(max(elements, key=len))
+  for filename in elements :
+    if useColor :
+      print("\t{}".format(colorFunction(filename)), file=destination)
+    else :
+      print("\t{:{}} {}".format(filename, maxColumnSize+2, resultStr), file=destination)
+################################################################################
+
+################################################################################
+def printEvaluationResult(destination, evaluationResult, useColor) :
+  name = evaluationResult[0]
+  correct = evaluationResult[1]["correct"]
+  incorrect = evaluationResult[1]["incorrect"]
+  notfound = evaluationResult[1]["notfound"]
+
+  nbCorrect = len(correct)
+  nbTotal = len(correct) + len(incorrect) + len(notfound)
+
+  score = 0.0
+  if nbTotal > 0 :
+    score = 100.0*nbCorrect/nbTotal
+  for dest, color in [(destination, useColor), (open(outputFilename, "a"), False)] :
+    print("Évaluation de %s :"%name, file=dest)
+    print("{}/{} correct ({:6.2f}%)".format(nbCorrect, nbTotal, score), file=dest)
+    if nbCorrect+len(incorrect) > 0 :
+      printListElements(dest, correct, green, color, "CORRECT")
+      printListElements(dest, incorrect, purple, color, "INCORRECT")
+      printListElements(dest, notfound, red, color, "NON-EXISTANT")
+  return score
+################################################################################
+
+################################################################################
+if __name__ == "__main__" :
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--verbose", "-v", default=False, action="store_true",
+    help="Verbose output (obsolete, verbose is default).")
+  parser.add_argument("--silent", "-s", default=False, action="store_true",
+    help="Less verbose output.")
+  parser.add_argument("--noColors", default=False, action="store_true",
+    help="Disable colors in output.")
+  parser.add_argument("--clean", "-c", default=False, action="store_true",
+    help="Clean input dir then exit.")
+  parser.add_argument("--number", "-n", default=None, type=int,
+    help="Restrict tests to n inputs.")
+  parser.add_argument("--files", "-f", default=[], nargs="*",
+    help="Specify input files.")
+  args = parser.parse_args()
+
+  args.verbose = not args.silent
+
+  if args.verbose :
+    outVerbose = outScore
+  if args.clean :
+      deleteCompilationOutputs()
+      exit(0)
+
+  with open(outputFilename, "w") as _ :
+    pass
+
+  inputFiles = args.files[:args.number]
+  if len(inputFiles) == 0 :
+    inputFiles = findInputFiles(inputPath)[:args.number]
+
+  errInputFilesTs = [errInputPathTs+"/"+f for f in findInputFiles(errInputPathTs)[:args.number]]
+  errInputFilesType = [errInputPathType+"/"+f for f in findInputFiles(errInputPathType)[:args.number]]
+
+  deleteCompilationOutputs()
+
+  compileCompiler()
+
+
+  scores = []
+  names = []
+  errors = []
+  names.append("SC           ")
+  res = compileInputFiles(inputFiles)
+  scores.append(printEvaluationResult(outVerbose, res, not args.noColors))
+  msg = "Diff de %s"
+  dfSa = lambda files : (evaluateDiff(inputFiles, ".sa", ".sa", "sa-ref/", msg%"sa"), [])
+  dfTs = lambda files : (evaluateDiff(inputFiles, ".ts", ".ts", "ts-ref/", msg%"ts"), [])
+  dfC3a = lambda files : (evaluateDiff(inputFiles, ".c3a", ".c3a", "c3a-ref/", msg%"c3a"), [])
+  dfPreNasm = lambda files : (evaluateDiff(inputFiles, ".pre-nasm", ".pre-nasm", "pre-nasm-ref/", msg%"pre-nasm"), [])
+  dfNasm = lambda files : (evaluateDiff(inputFiles, ".nasm", ".nasm", "nasm-ref/", msg%"nasm"), [])
+
+  # Evaluation of normal (working) examples
+  for evalTarget in [ 
+                     ("SA-DIFF      ", dfSa),
+                     ("TS-DIFF      ", dfTs),
+                     ("SA           ", evaluateSa),
+                     ("C3A-DIFF     ", dfC3a),
+                     ("C3A          ", evaluateC3a),
+                     ("PRE-NASM-DIFF", dfPreNasm),
+                     ("PRE-NASM     ", evaluatePreNasm),
+                     ("NASM-DIFF    ", dfNasm),
+                     ("NASM         ", evaluateNasm),
+                     ("EXE          ", evaluateExecutable),
+                    ] :
+    names.append(evalTarget[0])
+    res, err = evalTarget[1](inputFiles)
+    scores.append(printEvaluationResult(outVerbose, res, not args.noColors))
+    errors += err
+
+  # Evaluation of ill formed examples, that should trigger a compilation error
+  for evalTarget in [
+                     ("ERR_TS       ", evaluateCompilationErrors, errInputFilesTs, ERR_SYMBOL_TABLE_CODE),
+                     ("ERR_TYPE     ", evaluateCompilationErrors, errInputFilesType, ERR_TYPE_CODE),
+                    ] :
+    names.append(evalTarget[0])
+    res = evalTarget[1](evalTarget[2], evalTarget[3], evalTarget[0])
+    scores.append(printEvaluationResult(outVerbose, res, not args.noColors))
+
+  deleteClasses()
+
+  # The rest of the script will now print the results
+
+  if not args.noColors :
+    print("Légende : {}  {}  {}".format(green("CORRECT"), purple("INCORRECT"), red("NON-EXISTANT")), file=outVerbose)
+
+  errorsStr = ""
+
+  if len(errors) > 0 :
+    errorsStr = "%s\n%s"%((30*"-")+("EVALUATION ERRORS")+(30*"-"), "\n\n".join(errors))
+
+  print(errorsStr)
+  print(errorsStr, file=open(outputFilename, "a"))
+
+  for i in range(len(scores)):
+    print(names[i], "\t", scores[i])
+  
+  print("Copy-pastable scores :", file=outScore)
+  print("\t".join(names), file=outScore)
+  print("\t".join(["%6.2f"%scores[i] for i in range(len(scores))]), file=outScore)
+
+  print("\nSauvegardé dans le fichier %s"%outputFilename)
+
+# les coefficients associés à chaque partie pour le calcul de la note finale
+  coeffs = [SC_COEFF, SA_DIFF_COEFF, TS_DIFF_COEFF, SA_COEFF, C3A_DIFF_COEFF, C3A_COEFF, PRE_NASM_DIFF, PRE_NASM_COEFF, NASM_DIFF_COEFF, NASM_COEFF, EXE_COEFF, ERR_TS_COEFF, ERR_TYPE_COEFF]
+
+# calcul de la note finale
+
+  note = 0
+  for i in range(len(scores)):
+    note += scores[i] / 100 * coeffs[i]
+  print ("note = ",  note)
+
+################################################################################
+
diff --git a/test/fg-ref/add1.fg b/test/fg-ref/add1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..c297a4b0cdcc49b86eeeee84cac8d8b15ee0b614
--- /dev/null
+++ b/test/fg-ref/add1.fg
@@ -0,0 +1,14 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	3	;
+8 : ( 9 )		add	r0,	10	;
+9 : ( 10 )		mov	eax,	r0	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( )		ret	;
diff --git a/test/fg-ref/add2.fg b/test/fg-ref/add2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..083fd7bb3f5294b4f0642a1a026e6fbc048433aa
--- /dev/null
+++ b/test/fg-ref/add2.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	2	;
+8 : ( 9 )		add	r0,	4	;
+9 : ( 10 )		mov	r1,	r0	;
+10 : ( 11 )		add	r1,	8	;
+11 : ( 12 )		mov	eax,	r1	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/affect1.fg b/test/fg-ref/affect1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..61923e559a20df2f28545356f23991fc6a510d07
--- /dev/null
+++ b/test/fg-ref/affect1.fg
@@ -0,0 +1,13 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [a],	1	;Affect
+8 : ( 9 )		mov	eax,	dword [a]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	0	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( )		ret	;
diff --git a/test/fg-ref/affect2.fg b/test/fg-ref/affect2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a464fa66abc92e73a7454714248bcb4c439400fa
--- /dev/null
+++ b/test/fg-ref/affect2.fg
@@ -0,0 +1,13 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	1	;Affect
+8 : ( 9 )		mov	eax,	dword [ebp-4*1]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	4	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( )		ret	;
diff --git a/test/fg-ref/affect3.fg b/test/fg-ref/affect3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..333c3c4f694a5103f43227ca7273fb6a3e31399f
--- /dev/null
+++ b/test/fg-ref/affect3.fg
@@ -0,0 +1,24 @@
+0 : ( 13 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp+4*3],	1	;Affect
+8 : ( 9 )		mov	eax,	dword [ebp+4*3]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	0	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( 13 )		ret	;
+13 : ( 14 )	main :	push	ebp	;sauvegarde la valeur de ebp
+14 : ( 15 )		mov	ebp,	esp	;nouvelle valeur de ebp
+15 : ( 16 )		sub	esp,	4	;allocation des variables locales
+16 : ( 17 )		push	3	;Param
+17 : ( 18 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+18 : ( 4 )		call	f	;
+19 : ( 20 )		pop	r0	;récupération de la valeur de retour
+20 : ( 21 )		add	esp,	4	;désallocation des arguments
+21 : ( 22 )		add	esp,	4	;désallocation des variables locales
+22 : ( 23 )		pop	ebp	;restaure la valeur de ebp
+23 : ( )		ret	;
diff --git a/test/fg-ref/and1.fg b/test/fg-ref/and1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..750f4f19d0e0a7af76586dc701ca28dc749dc6a8
--- /dev/null
+++ b/test/fg-ref/and1.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	3	;JumpIfEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l1	;JumpIfEqual 2
+10 : ( 11 )		mov	r4,	1	;JumpIfEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l1	;JumpIfEqual 2
+13 : ( 14 )		mov	r0,	1	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/and2.fg b/test/fg-ref/and2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..2a49f43dacb2a0742154fa625df1c052658b837a
--- /dev/null
+++ b/test/fg-ref/and2.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	4	;JumpIfEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l1	;JumpIfEqual 2
+10 : ( 11 )		mov	r4,	0	;JumpIfEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l1	;JumpIfEqual 2
+13 : ( 14 )		mov	r0,	1	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/and3.fg b/test/fg-ref/and3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..5a994c3f036918fb7952b07da87a605a7749e359
--- /dev/null
+++ b/test/fg-ref/and3.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	0	;JumpIfEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l1	;JumpIfEqual 2
+10 : ( 11 )		mov	r4,	1024	;JumpIfEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l1	;JumpIfEqual 2
+13 : ( 14 )		mov	r0,	1	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/and4.fg b/test/fg-ref/and4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..3c441deef07b0435c6ca6ff339189a87d2cbce7b
--- /dev/null
+++ b/test/fg-ref/and4.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	0	;JumpIfEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l1	;JumpIfEqual 2
+10 : ( 11 )		mov	r4,	0	;JumpIfEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l1	;JumpIfEqual 2
+13 : ( 14 )		mov	r0,	1	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/and5.fg b/test/fg-ref/and5.fg
new file mode 100644
index 0000000000000000000000000000000000000000..479056ecfdcff913dab31c24c5fa886641d18ec4
--- /dev/null
+++ b/test/fg-ref/and5.fg
@@ -0,0 +1,29 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r4,	1	;JumpIfEqual 1
+8 : ( 9 )		cmp	r4,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l3	;JumpIfEqual 2
+10 : ( 11 )		mov	r5,	0	;JumpIfEqual 1
+11 : ( 12 )		cmp	r5,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l3	;JumpIfEqual 2
+13 : ( 14 )		mov	r1,	1	;Affect
+14 : ( 16 )		jmp	l2	;Jump
+15 : ( 16 )	l3 :	mov	r1,	0	;Affect
+16 : ( 17 )	l2 :	cmp	r1,	0	;JumpIfEqual 1
+17 : ( 18 23 )		je	l1	;JumpIfEqual 2
+18 : ( 19 )		mov	r6,	1	;JumpIfEqual 1
+19 : ( 20 )		cmp	r6,	0	;on passe par un registre temporaire
+20 : ( 21 23 )		je	l1	;JumpIfEqual 2
+21 : ( 22 )		mov	r0,	1	;Affect
+22 : ( 24 )		jmp	l0	;Jump
+23 : ( 24 )	l1 :	mov	r0,	0	;Affect
+24 : ( 25 )	l0 :	mov	eax,	r0	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		add	esp,	0	;désallocation des variables locales
+27 : ( 28 )		pop	ebp	;restaure la valeur de ebp
+28 : ( )		ret	;
diff --git a/test/fg-ref/appel-param1.fg b/test/fg-ref/appel-param1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..41c20bf55f8ac21eb76c7f3c08ed369f540a61ed
--- /dev/null
+++ b/test/fg-ref/appel-param1.fg
@@ -0,0 +1,23 @@
+0 : ( 12 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	dword [ebp+4*3]	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	main :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	0	;allocation des variables locales
+15 : ( 16 )		push	1	;Param
+16 : ( 17 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+17 : ( 4 )		call	f	;
+18 : ( 19 )		pop	r0	;récupération de la valeur de retour
+19 : ( 20 )		add	esp,	4	;désallocation des arguments
+20 : ( 21 )		add	esp,	0	;désallocation des variables locales
+21 : ( 22 )		pop	ebp	;restaure la valeur de ebp
+22 : ( )		ret	;
diff --git a/test/fg-ref/appel-param2.fg b/test/fg-ref/appel-param2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..4b41c8033a613e3d8815c76b6b52d169ea05832c
--- /dev/null
+++ b/test/fg-ref/appel-param2.fg
@@ -0,0 +1,26 @@
+0 : ( 14 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	dword [ebp+4*4]	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		mov	eax,	dword [ebp+4*3]	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( 14 )		ret	;
+14 : ( 15 )	main :	push	ebp	;sauvegarde la valeur de ebp
+15 : ( 16 )		mov	ebp,	esp	;nouvelle valeur de ebp
+16 : ( 17 )		sub	esp,	0	;allocation des variables locales
+17 : ( 18 )		push	1	;Param
+18 : ( 19 )		push	456	;Param
+19 : ( 20 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+20 : ( 4 )		call	f	;
+21 : ( 22 )		pop	r0	;récupération de la valeur de retour
+22 : ( 23 )		add	esp,	8	;désallocation des arguments
+23 : ( 24 )		add	esp,	0	;désallocation des variables locales
+24 : ( 25 )		pop	ebp	;restaure la valeur de ebp
+25 : ( )		ret	;
diff --git a/test/fg-ref/appel-param3.fg b/test/fg-ref/appel-param3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a4d722885c65c145f81518b5290a2f3bf7d4e3d6
--- /dev/null
+++ b/test/fg-ref/appel-param3.fg
@@ -0,0 +1,35 @@
+0 : ( 20 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	dword [ebp+4*7]	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		mov	eax,	dword [ebp+4*6]	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		mov	eax,	dword [ebp+4*5]	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		mov	eax,	dword [ebp+4*4]	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )		mov	eax,	dword [ebp+4*3]	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		add	esp,	0	;désallocation des variables locales
+18 : ( 19 )		pop	ebp	;restaure la valeur de ebp
+19 : ( 20 )		ret	;
+20 : ( 21 )	main :	push	ebp	;sauvegarde la valeur de ebp
+21 : ( 22 )		mov	ebp,	esp	;nouvelle valeur de ebp
+22 : ( 23 )		sub	esp,	0	;allocation des variables locales
+23 : ( 24 )		push	1	;Param
+24 : ( 25 )		push	2	;Param
+25 : ( 26 )		push	3	;Param
+26 : ( 27 )		push	4	;Param
+27 : ( 28 )		push	5	;Param
+28 : ( 29 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+29 : ( 4 )		call	f	;
+30 : ( 31 )		pop	r0	;récupération de la valeur de retour
+31 : ( 32 )		add	esp,	20	;désallocation des arguments
+32 : ( 33 )		add	esp,	0	;désallocation des variables locales
+33 : ( 34 )		pop	ebp	;restaure la valeur de ebp
+34 : ( )		ret	;
diff --git a/test/fg-ref/appel-retour1.fg b/test/fg-ref/appel-retour1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..dc08c96b52c2860645051c11d697e5c9ae1c0243
--- /dev/null
+++ b/test/fg-ref/appel-retour1.fg
@@ -0,0 +1,25 @@
+0 : ( 12 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	dword [ebp+4*3]	;ecriture de la valeur de retour
+8 : ( 9 )		mov	dword [ebp+4*2],	r3	;on passe par un registre temporaire
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	main :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	0	;allocation des variables locales
+15 : ( 16 )		push	3712	;Param
+16 : ( 17 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+17 : ( 4 )		call	f	;
+18 : ( 19 )		pop	r0	;récupération de la valeur de retour
+19 : ( 20 )		add	esp,	4	;désallocation des arguments
+20 : ( 21 )		mov	eax,	r0	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fg-ref/appel1.fg b/test/fg-ref/appel1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..c3ca7daf7e5385c26a4dd80fddb071f661c00e21
--- /dev/null
+++ b/test/fg-ref/appel1.fg
@@ -0,0 +1,21 @@
+0 : ( 12 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	1	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	main :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	0	;allocation des variables locales
+15 : ( 16 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+16 : ( 4 )		call	f	;
+17 : ( 18 )		pop	r0	;récupération de la valeur de retour
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/appel2.fg b/test/fg-ref/appel2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..5dd804608886472fd1647cecd98d3a64224fe559
--- /dev/null
+++ b/test/fg-ref/appel2.fg
@@ -0,0 +1,32 @@
+0 : ( 23 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	g :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	2	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	f :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	0	;allocation des variables locales
+15 : ( 16 )		mov	eax,	1	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+18 : ( 4 )		call	g	;
+19 : ( 20 )		pop	r0	;récupération de la valeur de retour
+20 : ( 21 )		add	esp,	0	;désallocation des variables locales
+21 : ( 22 )		pop	ebp	;restaure la valeur de ebp
+22 : ( 23 )		ret	;
+23 : ( 24 )	main :	push	ebp	;sauvegarde la valeur de ebp
+24 : ( 25 )		mov	ebp,	esp	;nouvelle valeur de ebp
+25 : ( 26 )		sub	esp,	0	;allocation des variables locales
+26 : ( 27 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+27 : ( 12 )		call	f	;
+28 : ( 29 )		pop	r1	;récupération de la valeur de retour
+29 : ( 30 )		add	esp,	0	;désallocation des variables locales
+30 : ( 31 )		pop	ebp	;restaure la valeur de ebp
+31 : ( )		ret	;
diff --git a/test/fg-ref/appel3.fg b/test/fg-ref/appel3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d4964b38d5e6f891f2d9a655f9b12f9cc5216d17
--- /dev/null
+++ b/test/fg-ref/appel3.fg
@@ -0,0 +1,32 @@
+0 : ( 20 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	g :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	2	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	f :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	0	;allocation des variables locales
+15 : ( 16 )		mov	eax,	1	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		add	esp,	0	;désallocation des variables locales
+18 : ( 19 )		pop	ebp	;restaure la valeur de ebp
+19 : ( 20 )		ret	;
+20 : ( 21 )	main :	push	ebp	;sauvegarde la valeur de ebp
+21 : ( 22 )		mov	ebp,	esp	;nouvelle valeur de ebp
+22 : ( 23 )		sub	esp,	0	;allocation des variables locales
+23 : ( 24 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+24 : ( 12 )		call	f	;
+25 : ( 26 )		pop	r0	;récupération de la valeur de retour
+26 : ( 27 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+27 : ( 4 )		call	g	;
+28 : ( 29 )		pop	r1	;récupération de la valeur de retour
+29 : ( 30 )		add	esp,	0	;désallocation des variables locales
+30 : ( 31 )		pop	ebp	;restaure la valeur de ebp
+31 : ( )		ret	;
diff --git a/test/fg-ref/div1.fg b/test/fg-ref/div1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..eccd4daf88b1b827ad5b8c6cce1de005c22276c4
--- /dev/null
+++ b/test/fg-ref/div1.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	4	;
+8 : ( 9 )		mov	r4,	2	;
+9 : ( 10 )		idiv	r4	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	eax,	r0	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/div2.fg b/test/fg-ref/div2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..7a56fa1e252641e8788a12e7304f29a47177f723
--- /dev/null
+++ b/test/fg-ref/div2.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	0	;
+8 : ( 9 )		mov	r4,	712	;
+9 : ( 10 )		idiv	r4	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	eax,	r0	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/div3.fg b/test/fg-ref/div3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a7e922490cfbe32a9e48acbdb64e96335dddeab5
--- /dev/null
+++ b/test/fg-ref/div3.fg
@@ -0,0 +1,20 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	4	;
+8 : ( 9 )		mov	r5,	2	;
+9 : ( 10 )		idiv	r5	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	eax,	r0	;
+12 : ( 13 )		mov	r8,	2	;
+13 : ( 14 )		idiv	r8	;
+14 : ( 15 )		mov	r1,	eax	;
+15 : ( 16 )		mov	eax,	r1	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		add	esp,	0	;désallocation des variables locales
+18 : ( 19 )		pop	ebp	;restaure la valeur de ebp
+19 : ( )		ret	;
diff --git a/test/fg-ref/div4.fg b/test/fg-ref/div4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..1290454b530571b243af75450321cb41a6c32ebc
--- /dev/null
+++ b/test/fg-ref/div4.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	2	;
+8 : ( 9 )		mov	r4,	3	;
+9 : ( 10 )		idiv	r4	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	eax,	r0	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/ecrire1.fg b/test/fg-ref/ecrire1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..77c65e8da95708250210b31eb1a5083dd9dc9852
--- /dev/null
+++ b/test/fg-ref/ecrire1.fg
@@ -0,0 +1,12 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	3456	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( )		ret	;
diff --git a/test/fg-ref/ecrire2.fg b/test/fg-ref/ecrire2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..31b3bc51036fbe8b233aef6fe324c5b34772e9ca
--- /dev/null
+++ b/test/fg-ref/ecrire2.fg
@@ -0,0 +1,12 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	0	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( )		ret	;
diff --git a/test/fg-ref/egal1.fg b/test/fg-ref/egal1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..c8c0ce0dc531d573cc73c280a2b1b198d23fca50
--- /dev/null
+++ b/test/fg-ref/egal1.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	123	;JumpIfEqual 1
+9 : ( 10 )		cmp	r3,	123	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/egal2.fg b/test/fg-ref/egal2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..4122164d5c7b174129908128a495133f8e7dd743
--- /dev/null
+++ b/test/fg-ref/egal2.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	412	;JumpIfEqual 1
+9 : ( 10 )		cmp	r3,	34	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/egal3.fg b/test/fg-ref/egal3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..7ceae358f33a4b1b49ca37a25012e1c8ae04f299
--- /dev/null
+++ b/test/fg-ref/egal3.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;Affect
+8 : ( 9 )		mov	r4,	2	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	2	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l1	;JumpIfEqual 2
+11 : ( 12 )		mov	r1,	0	;Affect
+12 : ( 13 )	l1 :	mov	r0,	1	;Affect
+13 : ( 14 )		cmp	r1,	1	;JumpIfEqual 1
+14 : ( 15 16 )		je	l0	;JumpIfEqual 2
+15 : ( 16 )		mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/err5.fg b/test/fg-ref/err5.fg
new file mode 100644
index 0000000000000000000000000000000000000000..be0611356e30443c121491fdfef97e270293fac5
--- /dev/null
+++ b/test/fg-ref/err5.fg
@@ -0,0 +1,22 @@
+0 : ( 12 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	1	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( 12 )		ret	;
+12 : ( 13 )	main :	push	ebp	;sauvegarde la valeur de ebp
+13 : ( 14 )		mov	ebp,	esp	;nouvelle valeur de ebp
+14 : ( 15 )		sub	esp,	4	;allocation des variables locales
+15 : ( 16 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+16 : ( 4 )		call	f	;
+17 : ( 18 )		pop	r0	;récupération de la valeur de retour
+18 : ( 19 )		mov	dword [ebp-4*1],	r0	;Affect
+19 : ( 20 )		add	esp,	4	;désallocation des variables locales
+20 : ( 21 )		pop	ebp	;restaure la valeur de ebp
+21 : ( )		ret	;
diff --git a/test/fg-ref/fibo.fg b/test/fg-ref/fibo.fg
new file mode 100644
index 0000000000000000000000000000000000000000..70c1ca0a2c54d771ef9cab630d10f0fc368bedcc
--- /dev/null
+++ b/test/fg-ref/fibo.fg
@@ -0,0 +1,80 @@
+0 : ( 1 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+1 : ( 2 )		call	main	;
+2 : ( 3 )		pop	r0	;récupération de la valeur de retour
+3 : ( 4 )		mov	ebx,	0	; valeur de retour du programme
+4 : ( 5 )		mov	eax,	1	; code de sortie
+5 : ( 6 )		int 0x80	;
+6 : ( 7 )	fibo :	push	ebp	;sauvegarde la valeur de ebp
+7 : ( 8 )		mov	ebp,	esp	;nouvelle valeur de ebp
+8 : ( 9 )		push	eax	;sauvegarde de eax
+9 : ( 10 )		push	ebx	;sauvegarde de ebx
+10 : ( 11 )		push	ecx	;sauvegarde de ecx
+11 : ( 12 )		push	edx	;sauvegarde de edx
+12 : ( 13 )		sub	esp,	0	;allocation des variables locales
+13 : ( 14 )		mov	r1,	1	;Affect
+14 : ( 15 )		cmp	dword [ebp+12],	2	;JumpIfLess 1
+15 : ( 16 17 )		jl	l2	;JumpIfLess 2
+16 : ( 17 )		mov	r1,	0	;Affect
+17 : ( 18 )	l2 :	cmp	r1,	0	;JumpIfEqual 1
+18 : ( 19 28 )		je	l0	;JumpIfEqual 2
+19 : ( 20 )		mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+20 : ( 21 )		add	esp,	0	;désallocation des variables locales
+21 : ( 22 )		pop	edx	;restaure edx
+22 : ( 23 )		pop	ecx	;restaure ecx
+23 : ( 24 )		pop	ebx	;restaure ebx
+24 : ( 25 )		pop	eax	;restaure eax
+25 : ( 26 )		pop	ebp	;restaure la valeur de ebp
+26 : ( )		ret	;
+27 : ( 52 )		jmp	l1	;Jump
+28 : ( 29 )	l0 :	mov	r3,	dword [ebp+12]	;
+29 : ( 30 )		sub	r3,	1	;
+30 : ( 31 )		push	r3	;Param
+31 : ( 32 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+32 : ( 33 )		call	fibo	;
+33 : ( 34 )		pop	r2	;récupération de la valeur de retour
+34 : ( 35 )		add	esp,	4	;désallocation des arguments
+35 : ( 36 )		mov	r5,	dword [ebp+12]	;
+36 : ( 37 )		sub	r5,	2	;
+37 : ( 38 )		push	r5	;Param
+38 : ( 39 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+39 : ( 40 )		call	fibo	;
+40 : ( 41 )		pop	r4	;récupération de la valeur de retour
+41 : ( 42 )		add	esp,	4	;désallocation des arguments
+42 : ( 43 )		mov	r6,	r2	;
+43 : ( 44 )		add	r6,	r4	;
+44 : ( 45 )		mov	dword [ebp+8],	r6	;ecriture de la valeur de retour
+45 : ( 46 )		add	esp,	0	;désallocation des variables locales
+46 : ( 47 )		pop	edx	;restaure edx
+47 : ( 48 )		pop	ecx	;restaure ecx
+48 : ( 49 )		pop	ebx	;restaure ebx
+49 : ( 50 )		pop	eax	;restaure eax
+50 : ( 51 )		pop	ebp	;restaure la valeur de ebp
+51 : ( )		ret	;
+52 : ( 53 )	l1 :	add	esp,	0	;désallocation des variables locales
+53 : ( 54 )		pop	edx	;restaure edx
+54 : ( 55 )		pop	ecx	;restaure ecx
+55 : ( 56 )		pop	ebx	;restaure ebx
+56 : ( 57 )		pop	eax	;restaure eax
+57 : ( 58 )		pop	ebp	;restaure la valeur de ebp
+58 : ( )		ret	;
+59 : ( 60 )	main :	push	ebp	;sauvegarde la valeur de ebp
+60 : ( 61 )		mov	ebp,	esp	;nouvelle valeur de ebp
+61 : ( 62 )		push	eax	;sauvegarde de eax
+62 : ( 63 )		push	ebx	;sauvegarde de ebx
+63 : ( 64 )		push	ecx	;sauvegarde de ecx
+64 : ( 65 )		push	edx	;sauvegarde de edx
+65 : ( 66 )		sub	esp,	0	;allocation des variables locales
+66 : ( 67 )		push	9	;Param
+67 : ( 68 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+68 : ( 69 )		call	fibo	;
+69 : ( 70 )		pop	r7	;récupération de la valeur de retour
+70 : ( 71 )		add	esp,	4	;désallocation des arguments
+71 : ( 72 )		mov	eax,	r7	;Write 1
+72 : ( 73 )		call	iprintLF	;Write 2
+73 : ( 74 )		add	esp,	0	;désallocation des variables locales
+74 : ( 75 )		pop	edx	;restaure edx
+75 : ( 76 )		pop	ecx	;restaure ecx
+76 : ( 77 )		pop	ebx	;restaure ebx
+77 : ( 78 )		pop	eax	;restaure eax
+78 : ( 79 )		pop	ebp	;restaure la valeur de ebp
+79 : ( )		ret	;
diff --git a/test/fg-ref/inf1.fg b/test/fg-ref/inf1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..3b96a9b590a16b4a6bc0e08ee098ac2a24cd2f5f
--- /dev/null
+++ b/test/fg-ref/inf1.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	3	;JumpIfLess 1
+9 : ( 10 )		cmp	r3,	3	;on passe par un registre temporaire
+10 : ( 11 12 )		jl	l0	;JumpIfLess 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/inf2.fg b/test/fg-ref/inf2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..caaacf3a888d11e04579a4b3318c6608845b97c8
--- /dev/null
+++ b/test/fg-ref/inf2.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	4	;JumpIfLess 1
+9 : ( 10 )		cmp	r3,	1	;on passe par un registre temporaire
+10 : ( 11 12 )		jl	l0	;JumpIfLess 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/inf3.fg b/test/fg-ref/inf3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..22bb0d9c6d0354ca8ceb8dd70086ad6bfd6f6302
--- /dev/null
+++ b/test/fg-ref/inf3.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	312	;JumpIfLess 1
+9 : ( 10 )		cmp	r3,	475	;on passe par un registre temporaire
+10 : ( 11 12 )		jl	l0	;JumpIfLess 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/inf4.fg b/test/fg-ref/inf4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..3da39ecd80715d772fe05158ce89cf044cd25fec
--- /dev/null
+++ b/test/fg-ref/inf4.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;Affect
+8 : ( 9 )		mov	r4,	3	;JumpIfLess 1
+9 : ( 10 )		cmp	r4,	2	;on passe par un registre temporaire
+10 : ( 11 12 )		jl	l1	;JumpIfLess 2
+11 : ( 12 )		mov	r1,	0	;Affect
+12 : ( 13 )	l1 :	mov	r0,	1	;Affect
+13 : ( 14 )		cmp	r1,	1	;JumpIfLess 1
+14 : ( 15 16 )		jl	l0	;JumpIfLess 2
+15 : ( 16 )		mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/mult1.fg b/test/fg-ref/mult1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..227aefcc6309a3d041a5049dd0b492490e512a36
--- /dev/null
+++ b/test/fg-ref/mult1.fg
@@ -0,0 +1,14 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	2	;
+8 : ( 9 )		imul	r0,	3	;
+9 : ( 10 )		mov	eax,	r0	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( )		ret	;
diff --git a/test/fg-ref/mult2.fg b/test/fg-ref/mult2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..bc8b6a572cd54331008e439953359c254949a2e4
--- /dev/null
+++ b/test/fg-ref/mult2.fg
@@ -0,0 +1,14 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	0	;
+8 : ( 9 )		imul	r0,	321	;
+9 : ( 10 )		mov	eax,	r0	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( )		ret	;
diff --git a/test/fg-ref/mult3.fg b/test/fg-ref/mult3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..2e78fb659cd98a9a1f4359f3b324389de04a1515
--- /dev/null
+++ b/test/fg-ref/mult3.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	3	;
+8 : ( 9 )		imul	r0,	3	;
+9 : ( 10 )		mov	r1,	r0	;
+10 : ( 11 )		imul	r1,	2	;
+11 : ( 12 )		mov	eax,	r1	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/not1.fg b/test/fg-ref/not1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..7b67cd6a316daf71aa6f6a3f29f36786605de0c8
--- /dev/null
+++ b/test/fg-ref/not1.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	312	;JumpIfEqual 1
+9 : ( 10 )		cmp	r3,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/not2.fg b/test/fg-ref/not2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..6b7e91125a8953ac72f94b8a5069446fc61c12da
--- /dev/null
+++ b/test/fg-ref/not2.fg
@@ -0,0 +1,17 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r3,	0	;JumpIfEqual 1
+9 : ( 10 )		cmp	r3,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;Write 1
+13 : ( )		call	iprintLF	;Write 2
+14 : ( 15 )		add	esp,	0	;désallocation des variables locales
+15 : ( 16 )		pop	ebp	;restaure la valeur de ebp
+16 : ( )		ret	;
diff --git a/test/fg-ref/not3.fg b/test/fg-ref/not3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a2d3434d504d27f07fbe091e6b2047f448a45306
--- /dev/null
+++ b/test/fg-ref/not3.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;Affect
+8 : ( 9 )		mov	r4,	0	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l1	;JumpIfEqual 2
+11 : ( 12 )		mov	r1,	0	;Affect
+12 : ( 13 )	l1 :	mov	r0,	1	;Affect
+13 : ( 14 )		cmp	r1,	0	;JumpIfEqual 1
+14 : ( 15 16 )		je	l0	;JumpIfEqual 2
+15 : ( 16 )		mov	r0,	0	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/or1.fg b/test/fg-ref/or1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d5799f4ca475680639f5c7299f5d585910941ab3
--- /dev/null
+++ b/test/fg-ref/or1.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	1	;jumpIfNotEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		jne	l1	;jumpIfNotEqual 2
+10 : ( 11 )		mov	r4,	1	;jumpIfNotEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		jne	l1	;jumpIfNotEqual 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	1	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/or2.fg b/test/fg-ref/or2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..e56cdf04fc4550e62ba738f5794ef2b947600b48
--- /dev/null
+++ b/test/fg-ref/or2.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	1	;jumpIfNotEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		jne	l1	;jumpIfNotEqual 2
+10 : ( 11 )		mov	r4,	0	;jumpIfNotEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		jne	l1	;jumpIfNotEqual 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	1	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/or3.fg b/test/fg-ref/or3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..f045f74b20842f4707d1e6ef3282af2b74926f98
--- /dev/null
+++ b/test/fg-ref/or3.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	0	;jumpIfNotEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		jne	l1	;jumpIfNotEqual 2
+10 : ( 11 )		mov	r4,	315	;jumpIfNotEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		jne	l1	;jumpIfNotEqual 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	1	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/or4.fg b/test/fg-ref/or4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..f55660b5de239ad5156e7435d5f9cb69b7c3ad22
--- /dev/null
+++ b/test/fg-ref/or4.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	0	;jumpIfNotEqual 1
+8 : ( 9 )		cmp	r3,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		jne	l1	;jumpIfNotEqual 2
+10 : ( 11 )		mov	r4,	0	;jumpIfNotEqual 1
+11 : ( 12 )		cmp	r4,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		jne	l1	;jumpIfNotEqual 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 16 )		jmp	l0	;Jump
+15 : ( 16 )	l1 :	mov	r0,	1	;Affect
+16 : ( 17 )	l0 :	mov	eax,	r0	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/or5.fg b/test/fg-ref/or5.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a374a43dd26735a3a6c42f3df6d74b422c69907c
--- /dev/null
+++ b/test/fg-ref/or5.fg
@@ -0,0 +1,29 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r4,	0	;jumpIfNotEqual 1
+8 : ( 9 )		cmp	r4,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		jne	l3	;jumpIfNotEqual 2
+10 : ( 11 )		mov	r5,	1	;jumpIfNotEqual 1
+11 : ( 12 )		cmp	r5,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		jne	l3	;jumpIfNotEqual 2
+13 : ( 14 )		mov	r1,	0	;Affect
+14 : ( 16 )		jmp	l2	;Jump
+15 : ( 16 )	l3 :	mov	r1,	1	;Affect
+16 : ( 17 )	l2 :	cmp	r1,	0	;jumpIfNotEqual 1
+17 : ( 18 23 )		jne	l1	;jumpIfNotEqual 2
+18 : ( 19 )		mov	r6,	0	;jumpIfNotEqual 1
+19 : ( 20 )		cmp	r6,	0	;on passe par un registre temporaire
+20 : ( 21 23 )		jne	l1	;jumpIfNotEqual 2
+21 : ( 22 )		mov	r0,	0	;Affect
+22 : ( 24 )		jmp	l0	;Jump
+23 : ( 24 )	l1 :	mov	r0,	1	;Affect
+24 : ( 25 )	l0 :	mov	eax,	r0	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		add	esp,	0	;désallocation des variables locales
+27 : ( 28 )		pop	ebp	;restaure la valeur de ebp
+28 : ( )		ret	;
diff --git a/test/fg-ref/parenth1.fg b/test/fg-ref/parenth1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..cae97fc1354646dfb64d5ca7460215d8355867cf
--- /dev/null
+++ b/test/fg-ref/parenth1.fg
@@ -0,0 +1,12 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	1	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( )		ret	;
diff --git a/test/fg-ref/parenth2.fg b/test/fg-ref/parenth2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..11ce3211ad1ff2160e28224e052aafe9647540d3
--- /dev/null
+++ b/test/fg-ref/parenth2.fg
@@ -0,0 +1,12 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	2	;Write 1
+8 : ( )		call	iprintLF	;Write 2
+9 : ( 10 )		add	esp,	0	;désallocation des variables locales
+10 : ( 11 )		pop	ebp	;restaure la valeur de ebp
+11 : ( )		ret	;
diff --git a/test/fg-ref/prio23-1.fg b/test/fg-ref/prio23-1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..64a231603f13999c7ede7c1b4118b7805f6e029b
--- /dev/null
+++ b/test/fg-ref/prio23-1.fg
@@ -0,0 +1,19 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r4,	0	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	r1,	r0	;
+13 : ( 14 )		imul	r1,	10	;
+14 : ( 15 )		mov	eax,	r1	;Write 1
+15 : ( )		call	iprintLF	;Write 2
+16 : ( 17 )		add	esp,	0	;désallocation des variables locales
+17 : ( 18 )		pop	ebp	;restaure la valeur de ebp
+18 : ( )		ret	;
diff --git a/test/fg-ref/prio23-2.fg b/test/fg-ref/prio23-2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..40ad4e9a6db3bdf2c4e589888dccf811fbbd2294
--- /dev/null
+++ b/test/fg-ref/prio23-2.fg
@@ -0,0 +1,19 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r4,	10	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	r1,	3	;
+13 : ( 14 )		imul	r1,	r0	;
+14 : ( 15 )		mov	eax,	r1	;Write 1
+15 : ( )		call	iprintLF	;Write 2
+16 : ( 17 )		add	esp,	0	;désallocation des variables locales
+17 : ( 18 )		pop	ebp	;restaure la valeur de ebp
+18 : ( )		ret	;
diff --git a/test/fg-ref/prio23-3.fg b/test/fg-ref/prio23-3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..b816b703a80139ed48df8db2a877be2f5d5395b3
--- /dev/null
+++ b/test/fg-ref/prio23-3.fg
@@ -0,0 +1,21 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r4,	0	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	eax,	r0	;
+13 : ( 14 )		mov	r6,	1	;
+14 : ( 15 )		idiv	r6	;
+15 : ( 16 )		mov	r1,	eax	;
+16 : ( 17 )		mov	eax,	r1	;Write 1
+17 : ( )		call	iprintLF	;Write 2
+18 : ( 19 )		add	esp,	0	;désallocation des variables locales
+19 : ( 20 )		pop	ebp	;restaure la valeur de ebp
+20 : ( )		ret	;
diff --git a/test/fg-ref/prio23-4.fg b/test/fg-ref/prio23-4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..08cb33a7ebbf61fc4c4d73fb763d6e3036d5a658
--- /dev/null
+++ b/test/fg-ref/prio23-4.fg
@@ -0,0 +1,25 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	1	;Affect
+8 : ( 9 )		mov	r5,	1	;JumpIfEqual 1
+9 : ( 10 )		cmp	r5,	0	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l0	;JumpIfEqual 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l0 :	mov	r1,	1	;Affect
+13 : ( 14 )		mov	r6,	0	;JumpIfEqual 1
+14 : ( 15 )		cmp	r6,	0	;on passe par un registre temporaire
+15 : ( 16 17 )		je	l1	;JumpIfEqual 2
+16 : ( 17 )		mov	r1,	0	;Affect
+17 : ( 18 )	l1 :	mov	eax,	r0	;
+18 : ( 19 )		idiv	r1	;
+19 : ( 20 )		mov	r2,	eax	;
+20 : ( 21 )		mov	eax,	r2	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fg-ref/prio34-1.fg b/test/fg-ref/prio34-1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..9eeb40e66c40de5e1fc6dd43937e79c2174bb19c
--- /dev/null
+++ b/test/fg-ref/prio34-1.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	3	;
+8 : ( 9 )		imul	r0,	4	;
+9 : ( 10 )		mov	r1,	2	;
+10 : ( 11 )		add	r1,	r0	;
+11 : ( 12 )		mov	eax,	r1	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/prio34-2.fg b/test/fg-ref/prio34-2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..fb9014447bff969e3614644d9b14e01f9a856858
--- /dev/null
+++ b/test/fg-ref/prio34-2.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	2	;
+8 : ( 9 )		imul	r0,	3	;
+9 : ( 10 )		mov	r1,	r0	;
+10 : ( 11 )		sub	r1,	4	;
+11 : ( 12 )		mov	eax,	r1	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/prio34-3.fg b/test/fg-ref/prio34-3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..9c8c152734da0230e05601420830a0a1eae85377
--- /dev/null
+++ b/test/fg-ref/prio34-3.fg
@@ -0,0 +1,18 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	6	;
+8 : ( 9 )		mov	r5,	3	;
+9 : ( 10 )		idiv	r5	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	r1,	r0	;
+12 : ( 13 )		sub	r1,	72	;
+13 : ( 14 )		mov	eax,	r1	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )		add	esp,	0	;désallocation des variables locales
+16 : ( 17 )		pop	ebp	;restaure la valeur de ebp
+17 : ( )		ret	;
diff --git a/test/fg-ref/prio34-4.fg b/test/fg-ref/prio34-4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..9f93a0086765c41cfafeb28f2490e5701aaf71c4
--- /dev/null
+++ b/test/fg-ref/prio34-4.fg
@@ -0,0 +1,18 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	eax,	20	;
+8 : ( 9 )		mov	r5,	10	;
+9 : ( 10 )		idiv	r5	;
+10 : ( 11 )		mov	r0,	eax	;
+11 : ( 12 )		mov	r1,	6	;
+12 : ( 13 )		add	r1,	r0	;
+13 : ( 14 )		mov	eax,	r1	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )		add	esp,	0	;désallocation des variables locales
+16 : ( 17 )		pop	ebp	;restaure la valeur de ebp
+17 : ( )		ret	;
diff --git a/test/fg-ref/prio45-1.fg b/test/fg-ref/prio45-1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d74cf0c856d5be0aa8dee349cce4ff660a5288b8
--- /dev/null
+++ b/test/fg-ref/prio45-1.fg
@@ -0,0 +1,19 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	0	;
+8 : ( 9 )		add	r1,	1	;
+9 : ( 10 )		mov	r0,	1	;Affect
+10 : ( 11 )		mov	r4,	2	;JumpIfEqual 1
+11 : ( 12 )		cmp	r4,	r1	;on passe par un registre temporaire
+12 : ( 13 14 )		je	l0	;JumpIfEqual 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 15 )	l0 :	mov	eax,	r0	;Write 1
+15 : ( )		call	iprintLF	;Write 2
+16 : ( 17 )		add	esp,	0	;désallocation des variables locales
+17 : ( 18 )		pop	ebp	;restaure la valeur de ebp
+18 : ( )		ret	;
diff --git a/test/fg-ref/prio45-2.fg b/test/fg-ref/prio45-2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..296352a080b5edcdc9a094a021b1132d7a321478
--- /dev/null
+++ b/test/fg-ref/prio45-2.fg
@@ -0,0 +1,18 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;
+8 : ( 9 )		add	r1,	234	;
+9 : ( 10 )		mov	r0,	1	;Affect
+10 : ( 11 )		cmp	r1,	1	;JumpIfEqual 1
+11 : ( 12 13 )		je	l0	;JumpIfEqual 2
+12 : ( 13 )		mov	r0,	0	;Affect
+13 : ( 14 )	l0 :	mov	eax,	r0	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )		add	esp,	0	;désallocation des variables locales
+16 : ( 17 )		pop	ebp	;restaure la valeur de ebp
+17 : ( )		ret	;
diff --git a/test/fg-ref/prio45-3.fg b/test/fg-ref/prio45-3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..3d0b5347d9d21be9d2100cba6f2fd4902b948751
--- /dev/null
+++ b/test/fg-ref/prio45-3.fg
@@ -0,0 +1,19 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	11	;
+8 : ( 9 )		add	r1,	100	;
+9 : ( 10 )		mov	r0,	1	;Affect
+10 : ( 11 )		mov	r4,	12	;JumpIfLess 1
+11 : ( 12 )		cmp	r4,	r1	;on passe par un registre temporaire
+12 : ( 13 14 )		jl	l0	;JumpIfLess 2
+13 : ( 14 )		mov	r0,	0	;Affect
+14 : ( 15 )	l0 :	mov	eax,	r0	;Write 1
+15 : ( )		call	iprintLF	;Write 2
+16 : ( 17 )		add	esp,	0	;désallocation des variables locales
+17 : ( 18 )		pop	ebp	;restaure la valeur de ebp
+18 : ( )		ret	;
diff --git a/test/fg-ref/prio45-4.fg b/test/fg-ref/prio45-4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..9374e20bc759f442f0e58e6b8473f9b8b6a20a78
--- /dev/null
+++ b/test/fg-ref/prio45-4.fg
@@ -0,0 +1,18 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	21	;
+8 : ( 9 )		sub	r1,	21	;
+9 : ( 10 )		mov	r0,	1	;Affect
+10 : ( 11 )		cmp	r1,	1	;JumpIfLess 1
+11 : ( 12 13 )		jl	l0	;JumpIfLess 2
+12 : ( 13 )		mov	r0,	0	;Affect
+13 : ( 14 )	l0 :	mov	eax,	r0	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )		add	esp,	0	;désallocation des variables locales
+16 : ( 17 )		pop	ebp	;restaure la valeur de ebp
+17 : ( )		ret	;
diff --git a/test/fg-ref/prio56-1.fg b/test/fg-ref/prio56-1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..52cb8267443ef1803c8eff595649ed80655a7b97
--- /dev/null
+++ b/test/fg-ref/prio56-1.fg
@@ -0,0 +1,25 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;Affect
+8 : ( 9 )		mov	r4,	1	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	2	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l2	;JumpIfEqual 2
+11 : ( 12 )		mov	r1,	0	;Affect
+12 : ( 13 )	l2 :	cmp	r1,	0	;JumpIfEqual 1
+13 : ( 14 19 )		je	l1	;JumpIfEqual 2
+14 : ( 15 )		mov	r5,	1	;JumpIfEqual 1
+15 : ( 16 )		cmp	r5,	0	;on passe par un registre temporaire
+16 : ( 17 19 )		je	l1	;JumpIfEqual 2
+17 : ( 18 )		mov	r0,	1	;Affect
+18 : ( 20 )		jmp	l0	;Jump
+19 : ( 20 )	l1 :	mov	r0,	0	;Affect
+20 : ( 21 )	l0 :	mov	eax,	r0	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fg-ref/prio56-2.fg b/test/fg-ref/prio56-2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..bf9bdabae21c4918132d25b3c3919e60bd3e1bb6
--- /dev/null
+++ b/test/fg-ref/prio56-2.fg
@@ -0,0 +1,25 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r1,	1	;Affect
+8 : ( 9 )		mov	r4,	2	;JumpIfEqual 1
+9 : ( 10 )		cmp	r4,	1	;on passe par un registre temporaire
+10 : ( 11 12 )		je	l2	;JumpIfEqual 2
+11 : ( 12 )		mov	r1,	0	;Affect
+12 : ( 13 )	l2 :	mov	r5,	1	;JumpIfEqual 1
+13 : ( 14 )		cmp	r5,	0	;on passe par un registre temporaire
+14 : ( 15 19 )		je	l1	;JumpIfEqual 2
+15 : ( 16 )		cmp	r1,	0	;JumpIfEqual 1
+16 : ( 17 19 )		je	l1	;JumpIfEqual 2
+17 : ( 18 )		mov	r0,	1	;Affect
+18 : ( 20 )		jmp	l0	;Jump
+19 : ( 20 )	l1 :	mov	r0,	0	;Affect
+20 : ( 21 )	l0 :	mov	eax,	r0	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fg-ref/prio67-1.fg b/test/fg-ref/prio67-1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..f7a44e62a3d634d4f6a4c004273a69ba1698c49d
--- /dev/null
+++ b/test/fg-ref/prio67-1.fg
@@ -0,0 +1,29 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r4,	0	;JumpIfEqual 1
+8 : ( 9 )		cmp	r4,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l3	;JumpIfEqual 2
+10 : ( 11 )		mov	r5,	1	;JumpIfEqual 1
+11 : ( 12 )		cmp	r5,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l3	;JumpIfEqual 2
+13 : ( 14 )		mov	r1,	1	;Affect
+14 : ( 16 )		jmp	l2	;Jump
+15 : ( 16 )	l3 :	mov	r1,	0	;Affect
+16 : ( 17 )	l2 :	cmp	r1,	0	;jumpIfNotEqual 1
+17 : ( 18 23 )		jne	l1	;jumpIfNotEqual 2
+18 : ( 19 )		mov	r6,	1	;jumpIfNotEqual 1
+19 : ( 20 )		cmp	r6,	0	;on passe par un registre temporaire
+20 : ( 21 23 )		jne	l1	;jumpIfNotEqual 2
+21 : ( 22 )		mov	r0,	0	;Affect
+22 : ( 24 )		jmp	l0	;Jump
+23 : ( 24 )	l1 :	mov	r0,	1	;Affect
+24 : ( 25 )	l0 :	mov	eax,	r0	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		add	esp,	0	;désallocation des variables locales
+27 : ( 28 )		pop	ebp	;restaure la valeur de ebp
+28 : ( )		ret	;
diff --git a/test/fg-ref/prio67-2.fg b/test/fg-ref/prio67-2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..2d932b72f1dc60d06447706b4032f65eec555ddc
--- /dev/null
+++ b/test/fg-ref/prio67-2.fg
@@ -0,0 +1,29 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r4,	1	;JumpIfEqual 1
+8 : ( 9 )		cmp	r4,	0	;on passe par un registre temporaire
+9 : ( 10 15 )		je	l3	;JumpIfEqual 2
+10 : ( 11 )		mov	r5,	0	;JumpIfEqual 1
+11 : ( 12 )		cmp	r5,	0	;on passe par un registre temporaire
+12 : ( 13 15 )		je	l3	;JumpIfEqual 2
+13 : ( 14 )		mov	r1,	1	;Affect
+14 : ( 16 )		jmp	l2	;Jump
+15 : ( 16 )	l3 :	mov	r1,	0	;Affect
+16 : ( 17 )	l2 :	mov	r6,	1	;jumpIfNotEqual 1
+17 : ( 18 )		cmp	r6,	0	;on passe par un registre temporaire
+18 : ( 19 23 )		jne	l1	;jumpIfNotEqual 2
+19 : ( 20 )		cmp	r1,	0	;jumpIfNotEqual 1
+20 : ( 21 23 )		jne	l1	;jumpIfNotEqual 2
+21 : ( 22 )		mov	r0,	0	;Affect
+22 : ( 24 )		jmp	l0	;Jump
+23 : ( 24 )	l1 :	mov	r0,	1	;Affect
+24 : ( 25 )	l0 :	mov	eax,	r0	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		add	esp,	0	;désallocation des variables locales
+27 : ( 28 )		pop	ebp	;restaure la valeur de ebp
+28 : ( )		ret	;
diff --git a/test/fg-ref/rec1.fg b/test/fg-ref/rec1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..755d8ec25bcc5d83855e2bbf6952da6e07c8cbb8
--- /dev/null
+++ b/test/fg-ref/rec1.fg
@@ -0,0 +1,73 @@
+0 : ( 1 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+1 : ( 2 )		call	main	;
+2 : ( 3 )		pop	r0	;récupération de la valeur de retour
+3 : ( 4 )		mov	ebx,	0	; valeur de retour du programme
+4 : ( 5 )		mov	eax,	1	; code de sortie
+5 : ( 6 )		int 0x80	;
+6 : ( 7 )	f :	push	ebp	;sauvegarde la valeur de ebp
+7 : ( 8 )		mov	ebp,	esp	;nouvelle valeur de ebp
+8 : ( 9 )		push	eax	;sauvegarde de eax
+9 : ( 10 )		push	ebx	;sauvegarde de ebx
+10 : ( 11 )		push	ecx	;sauvegarde de ecx
+11 : ( 12 )		push	edx	;sauvegarde de edx
+12 : ( 13 )		sub	esp,	0	;allocation des variables locales
+13 : ( 14 )		mov	r1,	1	;Affect
+14 : ( 15 )		cmp	dword [ebp+12],	1	;JumpIfEqual 1
+15 : ( 16 17 )		je	l2	;JumpIfEqual 2
+16 : ( 17 )		mov	r1,	0	;Affect
+17 : ( 18 )	l2 :	cmp	r1,	0	;JumpIfEqual 1
+18 : ( 19 28 )		je	l0	;JumpIfEqual 2
+19 : ( 20 )		mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+20 : ( 21 )		add	esp,	0	;désallocation des variables locales
+21 : ( 22 )		pop	edx	;restaure edx
+22 : ( 23 )		pop	ecx	;restaure ecx
+23 : ( 24 )		pop	ebx	;restaure ebx
+24 : ( 25 )		pop	eax	;restaure eax
+25 : ( 26 )		pop	ebp	;restaure la valeur de ebp
+26 : ( )		ret	;
+27 : ( 45 )		jmp	l1	;Jump
+28 : ( 29 )	l0 :	mov	r3,	dword [ebp+12]	;
+29 : ( 30 )		sub	r3,	1	;
+30 : ( 31 )		push	r3	;Param
+31 : ( 32 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+32 : ( 33 )		call	f	;
+33 : ( 34 )		pop	r2	;récupération de la valeur de retour
+34 : ( 35 )		add	esp,	4	;désallocation des arguments
+35 : ( 36 )		mov	r4,	1	;
+36 : ( 37 )		add	r4,	r2	;
+37 : ( 38 )		mov	dword [ebp+8],	r4	;ecriture de la valeur de retour
+38 : ( 39 )		add	esp,	0	;désallocation des variables locales
+39 : ( 40 )		pop	edx	;restaure edx
+40 : ( 41 )		pop	ecx	;restaure ecx
+41 : ( 42 )		pop	ebx	;restaure ebx
+42 : ( 43 )		pop	eax	;restaure eax
+43 : ( 44 )		pop	ebp	;restaure la valeur de ebp
+44 : ( )		ret	;
+45 : ( 46 )	l1 :	add	esp,	0	;désallocation des variables locales
+46 : ( 47 )		pop	edx	;restaure edx
+47 : ( 48 )		pop	ecx	;restaure ecx
+48 : ( 49 )		pop	ebx	;restaure ebx
+49 : ( 50 )		pop	eax	;restaure eax
+50 : ( 51 )		pop	ebp	;restaure la valeur de ebp
+51 : ( )		ret	;
+52 : ( 53 )	main :	push	ebp	;sauvegarde la valeur de ebp
+53 : ( 54 )		mov	ebp,	esp	;nouvelle valeur de ebp
+54 : ( 55 )		push	eax	;sauvegarde de eax
+55 : ( 56 )		push	ebx	;sauvegarde de ebx
+56 : ( 57 )		push	ecx	;sauvegarde de ecx
+57 : ( 58 )		push	edx	;sauvegarde de edx
+58 : ( 59 )		sub	esp,	0	;allocation des variables locales
+59 : ( 60 )		push	100	;Param
+60 : ( 61 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+61 : ( 62 )		call	f	;
+62 : ( 63 )		pop	r5	;récupération de la valeur de retour
+63 : ( 64 )		add	esp,	4	;désallocation des arguments
+64 : ( 65 )		mov	eax,	r5	;Write 1
+65 : ( 66 )		call	iprintLF	;Write 2
+66 : ( 67 )		add	esp,	0	;désallocation des variables locales
+67 : ( 68 )		pop	edx	;restaure edx
+68 : ( 69 )		pop	ecx	;restaure ecx
+69 : ( 70 )		pop	ebx	;restaure ebx
+70 : ( 71 )		pop	eax	;restaure eax
+71 : ( 72 )		pop	ebp	;restaure la valeur de ebp
+72 : ( )		ret	;
diff --git a/test/fg-ref/si1.fg b/test/fg-ref/si1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d613104da641d3cfe4eb9d712cd22257f85ffbe1
--- /dev/null
+++ b/test/fg-ref/si1.fg
@@ -0,0 +1,15 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r2,	1	;JumpIfEqual 1
+8 : ( 9 )		cmp	r2,	0	;on passe par un registre temporaire
+9 : ( 10 12 )		je	l1	;JumpIfEqual 2
+10 : ( 11 )		mov	eax,	1	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 13 )	l1 :	add	esp,	0	;désallocation des variables locales
+13 : ( 14 )		pop	ebp	;restaure la valeur de ebp
+14 : ( )		ret	;
diff --git a/test/fg-ref/si2.fg b/test/fg-ref/si2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..80160c1b2fd3c49220ff80ddb5fc0aadf930ed83
--- /dev/null
+++ b/test/fg-ref/si2.fg
@@ -0,0 +1,18 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r2,	0	;JumpIfEqual 1
+8 : ( 9 )		cmp	r2,	0	;on passe par un registre temporaire
+9 : ( 10 13 )		je	l0	;JumpIfEqual 2
+10 : ( 11 )		mov	eax,	1	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 15 )		jmp	l1	;Jump
+13 : ( 14 )	l0 :	mov	eax,	0	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )	l1 :	add	esp,	0	;désallocation des variables locales
+16 : ( 17 )		pop	ebp	;restaure la valeur de ebp
+17 : ( )		ret	;
diff --git a/test/fg-ref/si3.fg b/test/fg-ref/si3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..4a590860501d840bade594a94eb86574fb2cb462
--- /dev/null
+++ b/test/fg-ref/si3.fg
@@ -0,0 +1,20 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r2,	1	;JumpIfEqual 1
+8 : ( 9 )		cmp	r2,	0	;on passe par un registre temporaire
+9 : ( 10 13 )		je	l0	;JumpIfEqual 2
+10 : ( 11 )		mov	eax,	1	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 15 )		jmp	l1	;Jump
+13 : ( 14 )	l0 :	mov	eax,	0	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )	l1 :	mov	eax,	3	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		add	esp,	0	;désallocation des variables locales
+18 : ( 19 )		pop	ebp	;restaure la valeur de ebp
+19 : ( )		ret	;
diff --git a/test/fg-ref/si4.fg b/test/fg-ref/si4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..887ca3711058d0a8ae654c0b22de7d3a12feb41d
--- /dev/null
+++ b/test/fg-ref/si4.fg
@@ -0,0 +1,20 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r2,	0	;JumpIfEqual 1
+8 : ( 9 )		cmp	r2,	0	;on passe par un registre temporaire
+9 : ( 10 13 )		je	l0	;JumpIfEqual 2
+10 : ( 11 )		mov	eax,	1	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 15 )		jmp	l1	;Jump
+13 : ( 14 )	l0 :	mov	eax,	0	;Write 1
+14 : ( )		call	iprintLF	;Write 2
+15 : ( 16 )	l1 :	mov	eax,	3	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		add	esp,	0	;désallocation des variables locales
+18 : ( 19 )		pop	ebp	;restaure la valeur de ebp
+19 : ( )		ret	;
diff --git a/test/fg-ref/si5.fg b/test/fg-ref/si5.fg
new file mode 100644
index 0000000000000000000000000000000000000000..db829b986885138fddca78dbc7db1eea7a62706d
--- /dev/null
+++ b/test/fg-ref/si5.fg
@@ -0,0 +1,32 @@
+0 : ( 1 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+1 : ( 2 )		call	main	;
+2 : ( 3 )		pop	r0	;récupération de la valeur de retour
+3 : ( 4 )		mov	ebx,	0	; valeur de retour du programme
+4 : ( 5 )		mov	eax,	1	; code de sortie
+5 : ( 6 )		int 0x80	;
+6 : ( 7 )	main :	push	ebp	;sauvegarde la valeur de ebp
+7 : ( 8 )		mov	ebp,	esp	;nouvelle valeur de ebp
+8 : ( 9 )		push	eax	;sauvegarde de eax
+9 : ( 10 )		push	ebx	;sauvegarde de ebx
+10 : ( 11 )		push	ecx	;sauvegarde de ecx
+11 : ( 12 )		push	edx	;sauvegarde de edx
+12 : ( 13 )		sub	esp,	0	;allocation des variables locales
+13 : ( 14 )		mov	r7,	1	;JumpIfEqual 1
+14 : ( 15 )		cmp	r7,	0	;on passe par un registre temporaire
+15 : ( 16 23 )		je	l3	;JumpIfEqual 2
+16 : ( 17 )		mov	eax,	1	;Write 1
+17 : ( 18 )		call	iprintLF	;Write 2
+18 : ( 19 )		mov	r9,	1	;JumpIfEqual 1
+19 : ( 20 )		cmp	r9,	0	;on passe par un registre temporaire
+20 : ( 21 23 )		je	l3	;JumpIfEqual 2
+21 : ( 22 )		mov	eax,	2	;Write 1
+22 : ( 23 )		call	iprintLF	;Write 2
+23 : ( 24 )	l3 :	mov	eax,	3	;Write 1
+24 : ( 25 )		call	iprintLF	;Write 2
+25 : ( 26 )		add	esp,	0	;désallocation des variables locales
+26 : ( 27 )		pop	edx	;restaure edx
+27 : ( 28 )		pop	ecx	;restaure ecx
+28 : ( 29 )		pop	ebx	;restaure ebx
+29 : ( 30 )		pop	eax	;restaure eax
+30 : ( 31 )		pop	ebp	;restaure la valeur de ebp
+31 : ( )		ret	;
diff --git a/test/fg-ref/sub1.fg b/test/fg-ref/sub1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..e208bab202a1d40ba7fcc1db72823544eab5557d
--- /dev/null
+++ b/test/fg-ref/sub1.fg
@@ -0,0 +1,14 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	10	;
+8 : ( 9 )		sub	r0,	5	;
+9 : ( 10 )		mov	eax,	r0	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( )		ret	;
diff --git a/test/fg-ref/sub2.fg b/test/fg-ref/sub2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d9faa903d403252c129e7aba839bf460bedc8485
--- /dev/null
+++ b/test/fg-ref/sub2.fg
@@ -0,0 +1,14 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	7	;
+8 : ( 9 )		sub	r0,	20	;
+9 : ( 10 )		mov	eax,	r0	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		add	esp,	0	;désallocation des variables locales
+12 : ( 13 )		pop	ebp	;restaure la valeur de ebp
+13 : ( )		ret	;
diff --git a/test/fg-ref/sub3.fg b/test/fg-ref/sub3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..4d4b04e4377030744f7907f7298057f16c5a507d
--- /dev/null
+++ b/test/fg-ref/sub3.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r0,	2	;
+8 : ( 9 )		sub	r0,	1	;
+9 : ( 10 )		mov	r1,	r0	;
+10 : ( 11 )		sub	r1,	1	;
+11 : ( 12 )		mov	eax,	r1	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/tab1.fg b/test/fg-ref/tab1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..abbe0a107615f47f8f86827e7accfb087d3d8dc2
--- /dev/null
+++ b/test/fg-ref/tab1.fg
@@ -0,0 +1,25 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r2,	0	;
+8 : ( 9 )		mov	dword [tab+4*r2],	0	;Affect
+9 : ( 10 )		mov	r3,	1	;
+10 : ( 11 )		mov	dword [tab+4*r3],	1	;Affect
+11 : ( 12 )		mov	r4,	2	;
+12 : ( 13 )		mov	dword [tab+4*r4],	2	;Affect
+13 : ( 14 )		mov	r6,	0	;
+14 : ( 15 )		mov	eax,	dword [tab+4*r6]	;Write 1
+15 : ( )		call	iprintLF	;Write 2
+16 : ( 17 )		mov	r8,	1	;
+17 : ( 18 )		mov	eax,	dword [tab+4*r8]	;Write 1
+18 : ( )		call	iprintLF	;Write 2
+19 : ( 20 )		mov	r10,	2	;
+20 : ( 21 )		mov	eax,	dword [tab+4*r10]	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fg-ref/tab2.fg b/test/fg-ref/tab2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..ec815098d85d0e0ece4443b018df29389a99feb4
--- /dev/null
+++ b/test/fg-ref/tab2.fg
@@ -0,0 +1,32 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	2	;Affect
+8 : ( 9 )		mov	r0,	dword [ebp-4*1]	;
+9 : ( 10 )		add	r0,	0	;
+10 : ( 11 )		mov	r5,	r0	;
+11 : ( 12 )		mov	dword [tab+4*r5],	34	;Affect
+12 : ( 13 )		mov	r1,	dword [ebp-4*1]	;
+13 : ( 14 )		add	r1,	1	;
+14 : ( 15 )		mov	r6,	r1	;
+15 : ( 16 )		mov	dword [tab+4*r6],	74	;Affect
+16 : ( 17 )		mov	r2,	dword [ebp-4*1]	;
+17 : ( 18 )		add	r2,	2	;
+18 : ( 19 )		mov	r7,	r2	;
+19 : ( 20 )		mov	dword [tab+4*r7],	16	;Affect
+20 : ( 21 )		mov	r9,	2	;
+21 : ( 22 )		mov	eax,	dword [tab+4*r9]	;Write 1
+22 : ( )		call	iprintLF	;Write 2
+23 : ( 24 )		mov	r11,	3	;
+24 : ( 25 )		mov	eax,	dword [tab+4*r11]	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		mov	r13,	4	;
+27 : ( 28 )		mov	eax,	dword [tab+4*r13]	;Write 1
+28 : ( )		call	iprintLF	;Write 2
+29 : ( 30 )		add	esp,	4	;désallocation des variables locales
+30 : ( 31 )		pop	ebp	;restaure la valeur de ebp
+31 : ( )		ret	;
diff --git a/test/fg-ref/tab3.fg b/test/fg-ref/tab3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..fc912f651084c229398f825bc71a2552c4e51440
--- /dev/null
+++ b/test/fg-ref/tab3.fg
@@ -0,0 +1,35 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	8	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	2	;Affect
+8 : ( 9 )		mov	dword [ebp-4*2],	0	;Affect
+9 : ( 10 )		mov	r0,	dword [ebp-4*1]	;
+10 : ( 11 )		add	r0,	dword [ebp-4*2]	;
+11 : ( 12 )		mov	r5,	r0	;
+12 : ( 13 )		mov	dword [tab+4*r5],	34	;Affect
+13 : ( 14 )		mov	dword [ebp-4*2],	1	;Affect
+14 : ( 15 )		mov	r1,	dword [ebp-4*1]	;
+15 : ( 16 )		add	r1,	dword [ebp-4*2]	;
+16 : ( 17 )		mov	r6,	r1	;
+17 : ( 18 )		mov	dword [tab+4*r6],	74	;Affect
+18 : ( 19 )		mov	dword [ebp-4*2],	2	;Affect
+19 : ( 20 )		mov	r2,	dword [ebp-4*1]	;
+20 : ( 21 )		add	r2,	dword [ebp-4*2]	;
+21 : ( 22 )		mov	r7,	r2	;
+22 : ( 23 )		mov	dword [tab+4*r7],	16	;Affect
+23 : ( 24 )		mov	r9,	2	;
+24 : ( 25 )		mov	eax,	dword [tab+4*r9]	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		mov	r11,	3	;
+27 : ( 28 )		mov	eax,	dword [tab+4*r11]	;Write 1
+28 : ( )		call	iprintLF	;Write 2
+29 : ( 30 )		mov	r13,	4	;
+30 : ( 31 )		mov	eax,	dword [tab+4*r13]	;Write 1
+31 : ( )		call	iprintLF	;Write 2
+32 : ( 33 )		add	esp,	8	;désallocation des variables locales
+33 : ( 34 )		pop	ebp	;restaure la valeur de ebp
+34 : ( )		ret	;
diff --git a/test/fg-ref/tab4.fg b/test/fg-ref/tab4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..20eaf9bcb9a8cf74653312e3db0adbb8a744b592
--- /dev/null
+++ b/test/fg-ref/tab4.fg
@@ -0,0 +1,29 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	r3,	0	;
+8 : ( 9 )		mov	dword [tab+4*r3],	1	;Affect
+9 : ( 10 )		mov	r5,	0	;
+10 : ( 11 )		mov	r4,	dword [tab+4*r5]	;
+11 : ( 12 )		mov	dword [tab+4*r4],	12	;Affect
+12 : ( 13 )		mov	r6,	0	;
+13 : ( 14 )		mov	r0,	dword [tab+4*r6]	;
+14 : ( 15 )		add	r0,	1	;
+15 : ( 16 )		mov	r7,	r0	;
+16 : ( 17 )		mov	dword [tab+4*r7],	13	;Affect
+17 : ( 18 )		mov	r9,	0	;
+18 : ( 19 )		mov	eax,	dword [tab+4*r9]	;Write 1
+19 : ( )		call	iprintLF	;Write 2
+20 : ( 21 )		mov	r11,	1	;
+21 : ( 22 )		mov	eax,	dword [tab+4*r11]	;Write 1
+22 : ( )		call	iprintLF	;Write 2
+23 : ( 24 )		mov	r13,	2	;
+24 : ( 25 )		mov	eax,	dword [tab+4*r13]	;Write 1
+25 : ( )		call	iprintLF	;Write 2
+26 : ( 27 )		add	esp,	0	;désallocation des variables locales
+27 : ( 28 )		pop	ebp	;restaure la valeur de ebp
+28 : ( )		ret	;
diff --git a/test/fg-ref/tantque1.fg b/test/fg-ref/tantque1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..55ad05905333245130db75f184611cf7f3868a5a
--- /dev/null
+++ b/test/fg-ref/tantque1.fg
@@ -0,0 +1,26 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	10	;Affect
+8 : ( 9 )	l0 :	mov	r0,	1	;Affect
+9 : ( 10 )		mov	r4,	0	;JumpIfLess 1
+10 : ( 11 )		cmp	r4,	dword [ebp-4*1]	;on passe par un registre temporaire
+11 : ( 12 13 )		jl	l2	;JumpIfLess 2
+12 : ( 13 )		mov	r0,	0	;Affect
+13 : ( 14 )	l2 :	cmp	r0,	0	;JumpIfEqual 1
+14 : ( 15 21 )		je	l1	;JumpIfEqual 2
+15 : ( 16 )		mov	eax,	dword [ebp-4*1]	;Write 1
+16 : ( )		call	iprintLF	;Write 2
+17 : ( 18 )		mov	r1,	dword [ebp-4*1]	;
+18 : ( 19 )		sub	r1,	1	;
+19 : ( 20 )		mov	dword [ebp-4*1],	r1	;Affect
+20 : ( 8 )		jmp	l0	;Jump
+21 : ( 22 )	l1 :	mov	eax,	0	;Write 1
+22 : ( )		call	iprintLF	;Write 2
+23 : ( 24 )		add	esp,	4	;désallocation des variables locales
+24 : ( 25 )		pop	ebp	;restaure la valeur de ebp
+25 : ( )		ret	;
diff --git a/test/fg-ref/tantque2.fg b/test/fg-ref/tantque2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..2c74761389a78ca6265596846219675c0c8f9841
--- /dev/null
+++ b/test/fg-ref/tantque2.fg
@@ -0,0 +1,36 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	8	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	0	;Affect
+8 : ( 9 )	l0 :	mov	r0,	1	;Affect
+9 : ( 10 )		cmp	dword [ebp-4*1],	4	;JumpIfLess 1
+10 : ( 11 12 )		jl	l2	;JumpIfLess 2
+11 : ( 12 )		mov	r0,	0	;Affect
+12 : ( 13 )	l2 :	cmp	r0,	0	;JumpIfEqual 1
+13 : ( 14 33 )		je	l1	;JumpIfEqual 2
+14 : ( 15 )		mov	dword [ebp-4*2],	0	;Affect
+15 : ( 16 )	l3 :	mov	r1,	1	;Affect
+16 : ( 17 )		cmp	dword [ebp-4*2],	4	;JumpIfLess 1
+17 : ( 18 19 )		jl	l5	;JumpIfLess 2
+18 : ( 19 )		mov	r1,	0	;Affect
+19 : ( 20 )	l5 :	cmp	r1,	0	;JumpIfEqual 1
+20 : ( 21 29 )		je	l4	;JumpIfEqual 2
+21 : ( 22 )		mov	eax,	dword [ebp-4*1]	;Write 1
+22 : ( )		call	iprintLF	;Write 2
+23 : ( 24 )		mov	eax,	dword [ebp-4*2]	;Write 1
+24 : ( )		call	iprintLF	;Write 2
+25 : ( 26 )		mov	r2,	dword [ebp-4*2]	;
+26 : ( 27 )		add	r2,	1	;
+27 : ( 28 )		mov	dword [ebp-4*2],	r2	;Affect
+28 : ( 15 )		jmp	l3	;Jump
+29 : ( 30 )	l4 :	mov	r3,	dword [ebp-4*1]	;
+30 : ( 31 )		add	r3,	1	;
+31 : ( 32 )		mov	dword [ebp-4*1],	r3	;Affect
+32 : ( 8 )		jmp	l0	;Jump
+33 : ( 34 )	l1 :	add	esp,	8	;désallocation des variables locales
+34 : ( 35 )		pop	ebp	;restaure la valeur de ebp
+35 : ( )		ret	;
diff --git a/test/fg-ref/varglob1.fg b/test/fg-ref/varglob1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d577f3cd5d890cf4dce69d172b40a9a684385bb3
--- /dev/null
+++ b/test/fg-ref/varglob1.fg
@@ -0,0 +1,13 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [variable],	6834	;Affect
+8 : ( 9 )		mov	eax,	dword [variable]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	0	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( )		ret	;
diff --git a/test/fg-ref/varglob2.fg b/test/fg-ref/varglob2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..5dff65ae529b31798cfc70ab9c2817f4972a4021
--- /dev/null
+++ b/test/fg-ref/varglob2.fg
@@ -0,0 +1,15 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [variable],	10	;Affect
+8 : ( 9 )		mov	r0,	dword [variable]	;
+9 : ( 10 )		add	r0,	50	;
+10 : ( 11 )		mov	eax,	r0	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 13 )		add	esp,	0	;désallocation des variables locales
+13 : ( 14 )		pop	ebp	;restaure la valeur de ebp
+14 : ( )		ret	;
diff --git a/test/fg-ref/varglob3.fg b/test/fg-ref/varglob3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..869643f577fc57720f16820fd8f03d49a11d537f
--- /dev/null
+++ b/test/fg-ref/varglob3.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [var1],	10	;Affect
+8 : ( 9 )		mov	dword [var2],	34	;Affect
+9 : ( 10 )		mov	eax,	dword [var1]	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		mov	eax,	dword [var2]	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/varglob4.fg b/test/fg-ref/varglob4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..e020f5667fd2f0c402d16059ea5f8a05f2a49780
--- /dev/null
+++ b/test/fg-ref/varglob4.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	0	;allocation des variables locales
+7 : ( 8 )		mov	dword [var1],	10	;Affect
+8 : ( 9 )		mov	dword [var2],	34	;Affect
+9 : ( 10 )		mov	r0,	dword [var1]	;
+10 : ( 11 )		add	r0,	dword [var2]	;
+11 : ( 12 )		mov	eax,	r0	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	0	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/varloc1.fg b/test/fg-ref/varloc1.fg
new file mode 100644
index 0000000000000000000000000000000000000000..292336df32d5234203c6ec9942a4c93939e7d099
--- /dev/null
+++ b/test/fg-ref/varloc1.fg
@@ -0,0 +1,13 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	6834	;Affect
+8 : ( 9 )		mov	eax,	dword [ebp-4*1]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	4	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( )		ret	;
diff --git a/test/fg-ref/varloc2.fg b/test/fg-ref/varloc2.fg
new file mode 100644
index 0000000000000000000000000000000000000000..6e14583eb8b5ffbbde31edcc388fc00486a933ea
--- /dev/null
+++ b/test/fg-ref/varloc2.fg
@@ -0,0 +1,15 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	10	;Affect
+8 : ( 9 )		mov	r0,	dword [ebp-4*1]	;
+9 : ( 10 )		add	r0,	50	;
+10 : ( 11 )		mov	eax,	r0	;Write 1
+11 : ( )		call	iprintLF	;Write 2
+12 : ( 13 )		add	esp,	4	;désallocation des variables locales
+13 : ( 14 )		pop	ebp	;restaure la valeur de ebp
+14 : ( )		ret	;
diff --git a/test/fg-ref/varloc3.fg b/test/fg-ref/varloc3.fg
new file mode 100644
index 0000000000000000000000000000000000000000..6d47bc1df632ab4c5cc25f13b7d8b20ec41e3ba4
--- /dev/null
+++ b/test/fg-ref/varloc3.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	8	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	10	;Affect
+8 : ( 9 )		mov	dword [ebp-4*2],	30	;Affect
+9 : ( 10 )		mov	eax,	dword [ebp-4*1]	;Write 1
+10 : ( )		call	iprintLF	;Write 2
+11 : ( 12 )		mov	eax,	dword [ebp-4*2]	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	8	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/varloc4.fg b/test/fg-ref/varloc4.fg
new file mode 100644
index 0000000000000000000000000000000000000000..d35e2915ba017b7214026c3be3215d2ee2b9d298
--- /dev/null
+++ b/test/fg-ref/varloc4.fg
@@ -0,0 +1,16 @@
+0 : ( 4 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	main :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	8	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	10	;Affect
+8 : ( 9 )		mov	dword [ebp-4*2],	30	;Affect
+9 : ( 10 )		mov	r0,	dword [ebp-4*1]	;
+10 : ( 11 )		add	r0,	dword [ebp-4*2]	;
+11 : ( 12 )		mov	eax,	r0	;Write 1
+12 : ( )		call	iprintLF	;Write 2
+13 : ( 14 )		add	esp,	8	;désallocation des variables locales
+14 : ( 15 )		pop	ebp	;restaure la valeur de ebp
+15 : ( )		ret	;
diff --git a/test/fg-ref/varloc5.fg b/test/fg-ref/varloc5.fg
new file mode 100644
index 0000000000000000000000000000000000000000..a4a15a3b506e80fc8f03eaa92515cc9d67554743
--- /dev/null
+++ b/test/fg-ref/varloc5.fg
@@ -0,0 +1,25 @@
+0 : ( 13 )		call	main	;
+1 : ( 2 )		mov	ebx,	0	; valeur de retour du programme
+2 : ( 3 )		mov	eax,	1	;
+3 : ( 4 )		int 0x80	;
+4 : ( 5 )	f :	push	ebp	;sauvegarde la valeur de ebp
+5 : ( 6 )		mov	ebp,	esp	;nouvelle valeur de ebp
+6 : ( 7 )		sub	esp,	4	;allocation des variables locales
+7 : ( 8 )		mov	dword [ebp-4*1],	10	;Affect
+8 : ( 9 )		mov	eax,	dword [ebp-4*1]	;Write 1
+9 : ( )		call	iprintLF	;Write 2
+10 : ( 11 )		add	esp,	4	;désallocation des variables locales
+11 : ( 12 )		pop	ebp	;restaure la valeur de ebp
+12 : ( 13 )		ret	;
+13 : ( 14 )	main :	push	ebp	;sauvegarde la valeur de ebp
+14 : ( 15 )		mov	ebp,	esp	;nouvelle valeur de ebp
+15 : ( 16 )		sub	esp,	0	;allocation des variables locales
+16 : ( 17 )		mov	dword [var1],	20	;Affect
+17 : ( 18 )		sub	esp,	4	;allocation mémoire pour la valeur de retour
+18 : ( 4 )		call	f	;
+19 : ( 20 )		pop	r0	;récupération de la valeur de retour
+20 : ( 21 )		mov	eax,	dword [var1]	;Write 1
+21 : ( )		call	iprintLF	;Write 2
+22 : ( 23 )		add	esp,	0	;désallocation des variables locales
+23 : ( 24 )		pop	ebp	;restaure la valeur de ebp
+24 : ( )		ret	;
diff --git a/test/fgs-ref/add1.fgs b/test/fgs-ref/add1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..17c0fa4b6fc4f774c5886e47cdb25f69a8e81070
--- /dev/null
+++ b/test/fgs-ref/add1.fgs
@@ -0,0 +1,15 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	3	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	10	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/add2.fgs b/test/fgs-ref/add2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d8a2e66f8fe6c42994bd79483c264723e8610ace
--- /dev/null
+++ b/test/fgs-ref/add2.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	2	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	4	;
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 		mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	8	;
+use = (1 ) def = (4 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/affect1.fgs b/test/fgs-ref/affect1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..859a4d2d1fefb2e9387c66915834cdc351e59c05
--- /dev/null
+++ b/test/fgs-ref/affect1.fgs
@@ -0,0 +1,14 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [a],	1	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [a]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/affect2.fgs b/test/fgs-ref/affect2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..b254e126217ee1595c5ef3925be11e55ba697c20
--- /dev/null
+++ b/test/fgs-ref/affect2.fgs
@@ -0,0 +1,14 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	1	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/affect3.fgs b/test/fgs-ref/affect3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..82b824f24c75edfaca1b0ed9f293981b32ec1cc1
--- /dev/null
+++ b/test/fgs-ref/affect3.fgs
@@ -0,0 +1,25 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp+4*3],	1	;Affect
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*3]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	3	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des arguments
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/and1.fgs b/test/fgs-ref/and1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..693935068b3d1125e2406f25f691d6eb607841d0
--- /dev/null
+++ b/test/fgs-ref/and1.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	3	;JumpIfEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	1	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/and2.fgs b/test/fgs-ref/and2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d0cb5b744acc86dccfd051ea48fb50e6b6112544
--- /dev/null
+++ b/test/fgs-ref/and2.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	4	;JumpIfEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/and3.fgs b/test/fgs-ref/and3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..6ce510711c9795242fa0b16bc0e37e1b89e3ad89
--- /dev/null
+++ b/test/fgs-ref/and3.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	0	;JumpIfEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	1024	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/and4.fgs b/test/fgs-ref/and4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..a83cb5aa55c3a979e8921fb13f699fd6c628e1e3
--- /dev/null
+++ b/test/fgs-ref/and4.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	0	;JumpIfEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/and5.fgs b/test/fgs-ref/and5.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..b0d28d20e458686fe8ea5fedf4602fef9852c328
--- /dev/null
+++ b/test/fgs-ref/and5.fgs
@@ -0,0 +1,30 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	1	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	0	;JumpIfEqual 1
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		jmp	l2	;Jump
+use = () def = (1 )	in = ()	 	out = (1 )	 	l3 :	mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (6 )	in = ()	 	out = (6 )	 		mov	r6,	1	;JumpIfEqual 1
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		cmp	r6,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (7 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel-param1.fgs b/test/fgs-ref/appel-param1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2e08d5744b3cd30db48af501e7d4f78fc2573ba5
--- /dev/null
+++ b/test/fgs-ref/appel-param1.fgs
@@ -0,0 +1,24 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*3]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	1	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des arguments
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel-param2.fgs b/test/fgs-ref/appel-param2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2ffaa3927dd30e5244f5b777ec8d2cc1a685ec97
--- /dev/null
+++ b/test/fgs-ref/appel-param2.fgs
@@ -0,0 +1,27 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*4]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*3]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	1	;Param
+use = () def = ()	in = ()	 	out = ()	 		push	456	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	8	;désallocation des arguments
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel-param3.fgs b/test/fgs-ref/appel-param3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..3bbb753332548d06983fc9b6ec3f866b880f2c37
--- /dev/null
+++ b/test/fgs-ref/appel-param3.fgs
@@ -0,0 +1,36 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*7]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*6]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (5 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*5]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (6 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*4]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (7 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp+4*3]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	1	;Param
+use = () def = ()	in = ()	 	out = ()	 		push	2	;Param
+use = () def = ()	in = ()	 	out = ()	 		push	3	;Param
+use = () def = ()	in = ()	 	out = ()	 		push	4	;Param
+use = () def = ()	in = ()	 	out = ()	 		push	5	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	20	;désallocation des arguments
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel-retour1.fgs b/test/fgs-ref/appel-retour1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..1b39c7976f1335b8948fd541463449c64eddd2c8
--- /dev/null
+++ b/test/fgs-ref/appel-retour1.fgs
@@ -0,0 +1,26 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	dword [ebp+4*3]	;ecriture de la valeur de retour
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		mov	dword [ebp+4*2],	r3	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	3712	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = (0 )	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = (0 )	 	out = (0 )	 		add	esp,	4	;désallocation des arguments
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel1.fgs b/test/fgs-ref/appel1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..9849940b8f0f8c051137d4d5877a03b21c1e459a
--- /dev/null
+++ b/test/fgs-ref/appel1.fgs
@@ -0,0 +1,22 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel2.fgs b/test/fgs-ref/appel2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..383566696df8008c58f9368119a8da3dc9e0fb4c
--- /dev/null
+++ b/test/fgs-ref/appel2.fgs
@@ -0,0 +1,33 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	g :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	2	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (5 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	g	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (1 )	in = ()	 	out = ()	 		pop	r1	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/appel3.fgs b/test/fgs-ref/appel3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..08f881217330ef26dcc05207fc696c0dd13bf8b8
--- /dev/null
+++ b/test/fgs-ref/appel3.fgs
@@ -0,0 +1,33 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	g :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	2	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (5 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	g	;
+use = () def = (1 )	in = ()	 	out = ()	 		pop	r1	;récupération de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/div1.fgs b/test/fgs-ref/div1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d1f10647a104f9d9ffcd5c9a434112233104fa0e
--- /dev/null
+++ b/test/fgs-ref/div1.fgs
@@ -0,0 +1,17 @@
+iter num = 20
+use = () def = ()	in = (5 )	 	out = (5 )	 		call	main	;
+use = () def = (1 )	in = (5 )	 	out = (5 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = (5 )	 	out = (5 )	 		mov	eax,	1	;
+use = () def = ()	in = (5 )	 	out = (5 )	 		int 0x80	;
+use = () def = ()	in = (5 )	 	out = (5 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = (5 )	 	out = (5 )	 		mov	eax,	4	;
+use = () def = (4 )	in = (5 )	 	out = (4 5 )	 		mov	r4,	2	;
+use = (4 ) def = ()	in = (4 5 )	 	out = (5 )	 		idiv	r4	;
+use = (5 ) def = (0 )	in = (5 )	 	out = (0 )	 		mov	r0,	eax	;
+use = (0 ) def = (6 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/div2.fgs b/test/fgs-ref/div2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..eeaaedbe3b323904b0ee4e6454c161a78d240dc6
--- /dev/null
+++ b/test/fgs-ref/div2.fgs
@@ -0,0 +1,17 @@
+iter num = 20
+use = () def = ()	in = (5 )	 	out = (5 )	 		call	main	;
+use = () def = (1 )	in = (5 )	 	out = (5 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = (5 )	 	out = (5 )	 		mov	eax,	1	;
+use = () def = ()	in = (5 )	 	out = (5 )	 		int 0x80	;
+use = () def = ()	in = (5 )	 	out = (5 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = (5 )	 	out = (5 )	 		mov	eax,	0	;
+use = () def = (4 )	in = (5 )	 	out = (4 5 )	 		mov	r4,	712	;
+use = (4 ) def = ()	in = (4 5 )	 	out = (5 )	 		idiv	r4	;
+use = (5 ) def = (0 )	in = (5 )	 	out = (0 )	 		mov	r0,	eax	;
+use = (0 ) def = (6 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/div3.fgs b/test/fgs-ref/div3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..1fb235a671243c1afcfd9946819cd8d9f9ad473c
--- /dev/null
+++ b/test/fgs-ref/div3.fgs
@@ -0,0 +1,21 @@
+iter num = 28
+use = () def = ()	in = (6 9 )	 	out = (6 9 )	 		call	main	;
+use = () def = (2 )	in = (6 9 )	 	out = (6 9 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = (6 9 )	 	out = (6 9 )	 		mov	eax,	1	;
+use = () def = ()	in = (6 9 )	 	out = (6 9 )	 		int 0x80	;
+use = () def = ()	in = (6 9 )	 	out = (6 9 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (6 9 )	 	out = (6 9 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (6 9 )	 	out = (6 9 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = (6 9 )	 	out = (6 9 )	 		mov	eax,	4	;
+use = () def = (5 )	in = (6 9 )	 	out = (5 6 9 )	 		mov	r5,	2	;
+use = (5 ) def = ()	in = (5 6 9 )	 	out = (6 9 )	 		idiv	r5	;
+use = (6 ) def = (0 )	in = (6 9 )	 	out = (0 9 )	 		mov	r0,	eax	;
+use = (0 ) def = (7 )	in = (0 9 )	 	out = (9 )	 		mov	eax,	r0	;
+use = () def = (8 )	in = (9 )	 	out = (8 9 )	 		mov	r8,	2	;
+use = (8 ) def = ()	in = (8 9 )	 	out = (9 )	 		idiv	r8	;
+use = (9 ) def = (1 )	in = (9 )	 	out = (1 )	 		mov	r1,	eax	;
+use = (1 ) def = (10 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/div4.fgs b/test/fgs-ref/div4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..388ed25f0d3482ae32b7ae1f4d980119ef025436
--- /dev/null
+++ b/test/fgs-ref/div4.fgs
@@ -0,0 +1,17 @@
+iter num = 20
+use = () def = ()	in = (5 )	 	out = (5 )	 		call	main	;
+use = () def = (1 )	in = (5 )	 	out = (5 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = (5 )	 	out = (5 )	 		mov	eax,	1	;
+use = () def = ()	in = (5 )	 	out = (5 )	 		int 0x80	;
+use = () def = ()	in = (5 )	 	out = (5 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (5 )	 	out = (5 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = (5 )	 	out = (5 )	 		mov	eax,	2	;
+use = () def = (4 )	in = (5 )	 	out = (4 5 )	 		mov	r4,	3	;
+use = (4 ) def = ()	in = (4 5 )	 	out = (5 )	 		idiv	r4	;
+use = (5 ) def = (0 )	in = (5 )	 	out = (0 )	 		mov	r0,	eax	;
+use = (0 ) def = (6 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/ecrire1.fgs b/test/fgs-ref/ecrire1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..b592fbbb79ff9c70bc8aa7e0095f2f4dfd3a00f5
--- /dev/null
+++ b/test/fgs-ref/ecrire1.fgs
@@ -0,0 +1,13 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	3456	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/ecrire2.fgs b/test/fgs-ref/ecrire2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..49681220f220d3f187d0f1bc1dd4918df78bb65e
--- /dev/null
+++ b/test/fgs-ref/ecrire2.fgs
@@ -0,0 +1,13 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/egal1.fgs b/test/fgs-ref/egal1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..0548751c846d9c7c66bd994e0b20ed48667c7005
--- /dev/null
+++ b/test/fgs-ref/egal1.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	123	;JumpIfEqual 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	123	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/egal2.fgs b/test/fgs-ref/egal2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..41b4e6b478489ea7b74ef10931f05e2e6bac1c65
--- /dev/null
+++ b/test/fgs-ref/egal2.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	412	;JumpIfEqual 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	34	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/egal3.fgs b/test/fgs-ref/egal3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..8122de067b2b5e3e66d301620b32abfc3e0c9eb4
--- /dev/null
+++ b/test/fgs-ref/egal3.fgs
@@ -0,0 +1,22 @@
+iter num = 11
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = (4 )	in = (1 )	 	out = (1 4 )	 		mov	r4,	2	;JumpIfEqual 1
+use = (4 ) def = ()	in = (1 4 )	 	out = (1 )	 		cmp	r4,	2	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l1	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 	l1 :	mov	r0,	1	;Affect
+use = (1 ) def = ()	in = (0 1 )	 	out = (0 )	 		cmp	r1,	1	;JumpIfEqual 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/err5.fgs b/test/fgs-ref/err5.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..a381c2737778c68846cf7e639cd94c59ec18c64d
--- /dev/null
+++ b/test/fgs-ref/err5.fgs
@@ -0,0 +1,23 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = (0 )	 		pop	r0	;récupération de la valeur de retour
+use = (0 ) def = ()	in = (0 )	 	out = ()	 		mov	dword [ebp-4*1],	r0	;Affect
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/fibo.fgs b/test/fgs-ref/fibo.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..5806ac51765c68d3f404664884d8e2c6d742f0c7
--- /dev/null
+++ b/test/fgs-ref/fibo.fgs
@@ -0,0 +1,81 @@
+iter num = 19
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = (8 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (9 )	in = ()	 	out = ()	 		mov	eax,	1	; code de sortie
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	fibo :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		push	eax	;sauvegarde de eax
+use = () def = ()	in = ()	 	out = ()	 		push	ebx	;sauvegarde de ebx
+use = () def = ()	in = ()	 	out = ()	 		push	ecx	;sauvegarde de ecx
+use = () def = ()	in = ()	 	out = ()	 		push	edx	;sauvegarde de edx
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		cmp	dword [ebp+12],	2	;JumpIfLess 1
+use = () def = ()	in = (1 )	 	out = (1 )	 		jl	l2	;JumpIfLess 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l0	;JumpIfEqual 2
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (14 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (15 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (16 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (17 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 		jmp	l1	;Jump
+use = () def = (3 )	in = ()	 	out = (3 )	 	l0 :	mov	r3,	dword [ebp+12]	;
+use = (3 ) def = (3 )	in = (3 )	 	out = ()	 		sub	r3,	1	;
+use = () def = ()	in = ()	 	out = ()	 		push	r3	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	fibo	;
+use = () def = (2 )	in = ()	 	out = (2 )	 		pop	r2	;récupération de la valeur de retour
+use = () def = ()	in = (2 )	 	out = (2 )	 		add	esp,	4	;désallocation des arguments
+use = () def = (5 )	in = (2 )	 	out = (2 5 )	 		mov	r5,	dword [ebp+12]	;
+use = (5 ) def = (5 )	in = (2 5 )	 	out = (2 )	 		sub	r5,	2	;
+use = () def = ()	in = (2 )	 	out = (2 )	 		push	r5	;Param
+use = () def = ()	in = (2 )	 	out = (2 )	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = (2 )	 	out = (2 )	 		call	fibo	;
+use = () def = (4 )	in = (2 )	 	out = (2 4 )	 		pop	r4	;récupération de la valeur de retour
+use = () def = ()	in = (2 4 )	 	out = (2 4 )	 		add	esp,	4	;désallocation des arguments
+use = (2 ) def = (6 )	in = (2 4 )	 	out = (4 6 )	 		mov	r6,	r2	;
+use = (4 6 ) def = (6 )	in = (4 6 )	 	out = (6 )	 		add	r6,	r4	;
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		mov	dword [ebp+8],	r6	;ecriture de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (18 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (19 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (20 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (21 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	l1 :	add	esp,	0	;désallocation des variables locales
+use = () def = (22 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (23 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (24 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (25 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		push	eax	;sauvegarde de eax
+use = () def = ()	in = ()	 	out = ()	 		push	ebx	;sauvegarde de ebx
+use = () def = ()	in = ()	 	out = ()	 		push	ecx	;sauvegarde de ecx
+use = () def = ()	in = ()	 	out = ()	 		push	edx	;sauvegarde de edx
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	9	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	fibo	;
+use = () def = (7 )	in = ()	 	out = (7 )	 		pop	r7	;récupération de la valeur de retour
+use = () def = ()	in = (7 )	 	out = (7 )	 		add	esp,	4	;désallocation des arguments
+use = (7 ) def = (30 )	in = (7 )	 	out = ()	 		mov	eax,	r7	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (31 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (32 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (33 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (34 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/inf1.fgs b/test/fgs-ref/inf1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..86888167350ed928c637874d6779e46aa41eb822
--- /dev/null
+++ b/test/fgs-ref/inf1.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	3	;JumpIfLess 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	3	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/inf2.fgs b/test/fgs-ref/inf2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..8be613be4f6de19743a5ace45dbbd420136d02d0
--- /dev/null
+++ b/test/fgs-ref/inf2.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	4	;JumpIfLess 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	1	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/inf3.fgs b/test/fgs-ref/inf3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..7484453388a8529a97ab53a106871b8566633092
--- /dev/null
+++ b/test/fgs-ref/inf3.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	312	;JumpIfLess 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	475	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/inf4.fgs b/test/fgs-ref/inf4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..7f8fd1c286bb814abbe5df8dc9a3374f00e410ab
--- /dev/null
+++ b/test/fgs-ref/inf4.fgs
@@ -0,0 +1,22 @@
+iter num = 11
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = (4 )	in = (1 )	 	out = (1 4 )	 		mov	r4,	3	;JumpIfLess 1
+use = (4 ) def = ()	in = (1 4 )	 	out = (1 )	 		cmp	r4,	2	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		jl	l1	;JumpIfLess 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 	l1 :	mov	r0,	1	;Affect
+use = (1 ) def = ()	in = (0 1 )	 	out = (0 )	 		cmp	r1,	1	;JumpIfLess 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/mult1.fgs b/test/fgs-ref/mult1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..744a496103431b17fbb3cdc8f520906198e54b16
--- /dev/null
+++ b/test/fgs-ref/mult1.fgs
@@ -0,0 +1,15 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	2	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		imul	r0,	3	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/mult2.fgs b/test/fgs-ref/mult2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..283b9c8f008d6a223344bdbff4793a7ecfd25712
--- /dev/null
+++ b/test/fgs-ref/mult2.fgs
@@ -0,0 +1,15 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		imul	r0,	321	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/mult3.fgs b/test/fgs-ref/mult3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..7a190b659155de7b8bf087eded03df410b9b619d
--- /dev/null
+++ b/test/fgs-ref/mult3.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	3	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		imul	r0,	3	;
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 		mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		imul	r1,	2	;
+use = (1 ) def = (4 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/not1.fgs b/test/fgs-ref/not1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..eab7c02a95e3840477fc7173ac6a463efdf087cb
--- /dev/null
+++ b/test/fgs-ref/not1.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	312	;JumpIfEqual 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/not2.fgs b/test/fgs-ref/not2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..73c8d3fd36ded41dd11f437fcd0f05acbd6b78f0
--- /dev/null
+++ b/test/fgs-ref/not2.fgs
@@ -0,0 +1,18 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (3 )	in = (0 )	 	out = (0 3 )	 		mov	r3,	0	;JumpIfEqual 1
+use = (3 ) def = ()	in = (0 3 )	 	out = (0 )	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/not3.fgs b/test/fgs-ref/not3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2a71dd0b634046efcd23b14404713a886c8954ce
--- /dev/null
+++ b/test/fgs-ref/not3.fgs
@@ -0,0 +1,22 @@
+iter num = 11
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = (4 )	in = (1 )	 	out = (1 4 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (1 4 )	 	out = (1 )	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l1	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 	l1 :	mov	r0,	1	;Affect
+use = (1 ) def = ()	in = (0 1 )	 	out = (0 )	 		cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/or1.fgs b/test/fgs-ref/or1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..aa71c4cb9b753ea840f899f9a59503132865f1a6
--- /dev/null
+++ b/test/fgs-ref/or1.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	1	;jumpIfNotEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	1	;jumpIfNotEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/or2.fgs b/test/fgs-ref/or2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..7094e618fd7bd0acbad38b3e22c11850acf82510
--- /dev/null
+++ b/test/fgs-ref/or2.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	1	;jumpIfNotEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;jumpIfNotEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/or3.fgs b/test/fgs-ref/or3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..5b331bd9e8ef1c33c6bace399871cff1895df758
--- /dev/null
+++ b/test/fgs-ref/or3.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	0	;jumpIfNotEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	315	;jumpIfNotEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/or4.fgs b/test/fgs-ref/or4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..86503bbfcdf08d3ed890544cb6eb5f55a4256764
--- /dev/null
+++ b/test/fgs-ref/or4.fgs
@@ -0,0 +1,22 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	0	;jumpIfNotEqual 1
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		cmp	r3,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;jumpIfNotEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/or5.fgs b/test/fgs-ref/or5.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..a14bf64d0d995cecf458b2a9a3972678d026da38
--- /dev/null
+++ b/test/fgs-ref/or5.fgs
@@ -0,0 +1,30 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;jumpIfNotEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l3	;jumpIfNotEqual 2
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	1	;jumpIfNotEqual 1
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l3	;jumpIfNotEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		jmp	l2	;Jump
+use = () def = (1 )	in = ()	 	out = (1 )	 	l3 :	mov	r1,	1	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;jumpIfNotEqual 1
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (6 )	in = ()	 	out = (6 )	 		mov	r6,	0	;jumpIfNotEqual 1
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		cmp	r6,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (7 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/parenth1.fgs b/test/fgs-ref/parenth1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2aed1a1e27a1f1ef99bb3d6f6771f7edb357e6bd
--- /dev/null
+++ b/test/fgs-ref/parenth1.fgs
@@ -0,0 +1,13 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/parenth2.fgs b/test/fgs-ref/parenth2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..8f2d29989ce9513dd4844fe46f6a89c01f29618b
--- /dev/null
+++ b/test/fgs-ref/parenth2.fgs
@@ -0,0 +1,13 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	2	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio23-1.fgs b/test/fgs-ref/prio23-1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d50f451ef61bf1ecd3755d7c1d6d6dcc580aa3fc
--- /dev/null
+++ b/test/fgs-ref/prio23-1.fgs
@@ -0,0 +1,20 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 )	 	out = (0 4 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (0 4 )	 	out = (0 )	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 	l0 :	mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		imul	r1,	10	;
+use = (1 ) def = (5 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio23-2.fgs b/test/fgs-ref/prio23-2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..ca8580fd0e16adac0f14cdc510236f716b841310
--- /dev/null
+++ b/test/fgs-ref/prio23-2.fgs
@@ -0,0 +1,20 @@
+iter num = 11
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 )	 	out = (0 4 )	 		mov	r4,	10	;JumpIfEqual 1
+use = (4 ) def = ()	in = (0 4 )	 	out = (0 )	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = (1 )	in = (0 )	 	out = (0 1 )	 	l0 :	mov	r1,	3	;
+use = (0 1 ) def = (1 )	in = (0 1 )	 	out = (1 )	 		imul	r1,	r0	;
+use = (1 ) def = (5 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio23-3.fgs b/test/fgs-ref/prio23-3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..6bb0cc3c91d82ef78e7d8d6c9b1e7eb5a0a651ac
--- /dev/null
+++ b/test/fgs-ref/prio23-3.fgs
@@ -0,0 +1,22 @@
+iter num = 28
+use = () def = ()	in = (7 )	 	out = (7 )	 		call	main	;
+use = () def = (2 )	in = (7 )	 	out = (7 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = (7 )	 	out = (7 )	 		mov	eax,	1	;
+use = () def = ()	in = (7 )	 	out = (7 )	 		int 0x80	;
+use = () def = ()	in = (7 )	 	out = (7 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (7 )	 	out = (7 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (7 )	 	out = (7 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = (7 )	 	out = (0 7 )	 		mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 7 )	 	out = (0 4 7 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (0 4 7 )	 	out = (0 7 )	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 7 )	 	out = (0 7 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = (7 )	 	out = (0 7 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 7 )	 	out = (7 )	 	l0 :	mov	eax,	r0	;
+use = () def = (6 )	in = (7 )	 	out = (6 7 )	 		mov	r6,	1	;
+use = (6 ) def = ()	in = (6 7 )	 	out = (7 )	 		idiv	r6	;
+use = (7 ) def = (1 )	in = (7 )	 	out = (1 )	 		mov	r1,	eax	;
+use = (1 ) def = (8 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio23-4.fgs b/test/fgs-ref/prio23-4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..31cb97ed7ea6a1d718d1169cea812aa639957796
--- /dev/null
+++ b/test/fgs-ref/prio23-4.fgs
@@ -0,0 +1,26 @@
+iter num = 34
+use = () def = ()	in = (8 )	 	out = (8 )	 		call	main	;
+use = () def = (3 )	in = (8 )	 	out = (8 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (4 )	in = (8 )	 	out = (8 )	 		mov	eax,	1	;
+use = () def = ()	in = (8 )	 	out = (8 )	 		int 0x80	;
+use = () def = ()	in = (8 )	 	out = (8 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (8 )	 	out = (8 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (8 )	 	out = (8 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = (8 )	 	out = (0 8 )	 		mov	r0,	1	;Affect
+use = () def = (5 )	in = (0 8 )	 	out = (0 5 8 )	 		mov	r5,	1	;JumpIfEqual 1
+use = (5 ) def = ()	in = (0 5 8 )	 	out = (0 8 )	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 8 )	 	out = (0 8 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = (8 )	 	out = (0 8 )	 		mov	r0,	0	;Affect
+use = () def = (1 )	in = (0 8 )	 	out = (0 1 8 )	 	l0 :	mov	r1,	1	;Affect
+use = () def = (6 )	in = (0 1 8 )	 	out = (0 1 6 8 )	 		mov	r6,	0	;JumpIfEqual 1
+use = (6 ) def = ()	in = (0 1 6 8 )	 	out = (0 1 8 )	 		cmp	r6,	0	;on passe par un registre temporaire
+use = () def = ()	in = (0 1 8 )	 	out = (0 1 8 )	 		je	l1	;JumpIfEqual 2
+use = () def = (1 )	in = (0 8 )	 	out = (0 1 8 )	 		mov	r1,	0	;Affect
+use = (0 ) def = (7 )	in = (0 1 8 )	 	out = (1 8 )	 	l1 :	mov	eax,	r0	;
+use = (1 ) def = ()	in = (1 8 )	 	out = (8 )	 		idiv	r1	;
+use = (8 ) def = (2 )	in = (8 )	 	out = (2 )	 		mov	r2,	eax	;
+use = (2 ) def = (9 )	in = (2 )	 	out = ()	 		mov	eax,	r2	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio34-1.fgs b/test/fgs-ref/prio34-1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..fadac07bb639a07a07789ab65389b9c3e6ab5f8f
--- /dev/null
+++ b/test/fgs-ref/prio34-1.fgs
@@ -0,0 +1,17 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	3	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		imul	r0,	4	;
+use = () def = (1 )	in = (0 )	 	out = (0 1 )	 		mov	r1,	2	;
+use = (0 1 ) def = (1 )	in = (0 1 )	 	out = (1 )	 		add	r1,	r0	;
+use = (1 ) def = (4 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio34-2.fgs b/test/fgs-ref/prio34-2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..ffeb7df9c19e5dd8d8b10f8ef42a9f13bdd8544e
--- /dev/null
+++ b/test/fgs-ref/prio34-2.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	2	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		imul	r0,	3	;
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 		mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		sub	r1,	4	;
+use = (1 ) def = (4 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio34-3.fgs b/test/fgs-ref/prio34-3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..aba865583aaa7417c42e5fc3c2058db173fcdbec
--- /dev/null
+++ b/test/fgs-ref/prio34-3.fgs
@@ -0,0 +1,19 @@
+iter num = 20
+use = () def = ()	in = (6 )	 	out = (6 )	 		call	main	;
+use = () def = (2 )	in = (6 )	 	out = (6 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = (6 )	 	out = (6 )	 		mov	eax,	1	;
+use = () def = ()	in = (6 )	 	out = (6 )	 		int 0x80	;
+use = () def = ()	in = (6 )	 	out = (6 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (6 )	 	out = (6 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (6 )	 	out = (6 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = (6 )	 	out = (6 )	 		mov	eax,	6	;
+use = () def = (5 )	in = (6 )	 	out = (5 6 )	 		mov	r5,	3	;
+use = (5 ) def = ()	in = (5 6 )	 	out = (6 )	 		idiv	r5	;
+use = (6 ) def = (0 )	in = (6 )	 	out = (0 )	 		mov	r0,	eax	;
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 		mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		sub	r1,	72	;
+use = (1 ) def = (7 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio34-4.fgs b/test/fgs-ref/prio34-4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..088f3df8f51b430dc173df14810ddb7583287391
--- /dev/null
+++ b/test/fgs-ref/prio34-4.fgs
@@ -0,0 +1,19 @@
+iter num = 20
+use = () def = ()	in = (6 )	 	out = (6 )	 		call	main	;
+use = () def = (2 )	in = (6 )	 	out = (6 )	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = (6 )	 	out = (6 )	 		mov	eax,	1	;
+use = () def = ()	in = (6 )	 	out = (6 )	 		int 0x80	;
+use = () def = ()	in = (6 )	 	out = (6 )	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = (6 )	 	out = (6 )	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = (6 )	 	out = (6 )	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = (6 )	 	out = (6 )	 		mov	eax,	20	;
+use = () def = (5 )	in = (6 )	 	out = (5 6 )	 		mov	r5,	10	;
+use = (5 ) def = ()	in = (5 6 )	 	out = (6 )	 		idiv	r5	;
+use = (6 ) def = (0 )	in = (6 )	 	out = (0 )	 		mov	r0,	eax	;
+use = () def = (1 )	in = (0 )	 	out = (0 1 )	 		mov	r1,	6	;
+use = (0 1 ) def = (1 )	in = (0 1 )	 	out = (1 )	 		add	r1,	r0	;
+use = (1 ) def = (7 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio45-1.fgs b/test/fgs-ref/prio45-1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..c4e774f1529ee2682e92985800da60863534f5f1
--- /dev/null
+++ b/test/fgs-ref/prio45-1.fgs
@@ -0,0 +1,20 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	1	;
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 		mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 1 )	 	out = (0 1 4 )	 		mov	r4,	2	;JumpIfEqual 1
+use = (1 4 ) def = ()	in = (0 1 4 )	 	out = (0 )	 		cmp	r4,	r1	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio45-2.fgs b/test/fgs-ref/prio45-2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..581d854b176806a7df8a56fdcc5319a400f87d57
--- /dev/null
+++ b/test/fgs-ref/prio45-2.fgs
@@ -0,0 +1,19 @@
+iter num = 7
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	234	;
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 		mov	r0,	1	;Affect
+use = (1 ) def = ()	in = (0 1 )	 	out = (0 )	 		cmp	r1,	1	;JumpIfEqual 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		je	l0	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio45-3.fgs b/test/fgs-ref/prio45-3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..9519f6c7f56230914cd5f92e90970663c02d1e5b
--- /dev/null
+++ b/test/fgs-ref/prio45-3.fgs
@@ -0,0 +1,20 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	11	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	100	;
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 		mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 1 )	 	out = (0 1 4 )	 		mov	r4,	12	;JumpIfLess 1
+use = (1 4 ) def = ()	in = (0 1 4 )	 	out = (0 )	 		cmp	r4,	r1	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (5 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio45-4.fgs b/test/fgs-ref/prio45-4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2e64d12074c2b6eebcb4a0ca99f7223b0b743b1d
--- /dev/null
+++ b/test/fgs-ref/prio45-4.fgs
@@ -0,0 +1,19 @@
+iter num = 7
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	21	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		sub	r1,	21	;
+use = () def = (0 )	in = (1 )	 	out = (0 1 )	 		mov	r0,	1	;Affect
+use = (1 ) def = ()	in = (0 1 )	 	out = (0 )	 		cmp	r1,	1	;JumpIfLess 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l0	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = (4 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio56-1.fgs b/test/fgs-ref/prio56-1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..7b84beb610d28138690c6d6a5122758c9d70c39f
--- /dev/null
+++ b/test/fgs-ref/prio56-1.fgs
@@ -0,0 +1,26 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = (4 )	in = (1 )	 	out = (1 4 )	 		mov	r4,	1	;JumpIfEqual 1
+use = (4 ) def = ()	in = (1 4 )	 	out = (1 )	 		cmp	r4,	2	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l2	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	1	;JumpIfEqual 1
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (6 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio56-2.fgs b/test/fgs-ref/prio56-2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..f4c98ddf8009f15a5494083f092c14394b9b1862
--- /dev/null
+++ b/test/fgs-ref/prio56-2.fgs
@@ -0,0 +1,26 @@
+iter num = 15
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = (4 )	in = (1 )	 	out = (1 4 )	 		mov	r4,	2	;JumpIfEqual 1
+use = (4 ) def = ()	in = (1 4 )	 	out = (1 )	 		cmp	r4,	1	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l2	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = () def = (5 )	in = (1 )	 	out = (1 5 )	 	l2 :	mov	r5,	1	;JumpIfEqual 1
+use = (5 ) def = ()	in = (1 5 )	 	out = (1 )	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l1	;JumpIfEqual 2
+use = (1 ) def = ()	in = (1 )	 	out = ()	 		cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	0	;Affect
+use = (0 ) def = (6 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio67-1.fgs b/test/fgs-ref/prio67-1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..daa97c7ab6dcb65ba752750b257f502f2147eedf
--- /dev/null
+++ b/test/fgs-ref/prio67-1.fgs
@@ -0,0 +1,30 @@
+iter num = 5
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	0	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	1	;JumpIfEqual 1
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		jmp	l2	;Jump
+use = () def = (1 )	in = ()	 	out = (1 )	 	l3 :	mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;jumpIfNotEqual 1
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (6 )	in = ()	 	out = (6 )	 		mov	r6,	1	;jumpIfNotEqual 1
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		cmp	r6,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (7 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/prio67-2.fgs b/test/fgs-ref/prio67-2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..2837740b65a52e5d35eed62373dd2c52014be0d3
--- /dev/null
+++ b/test/fgs-ref/prio67-2.fgs
@@ -0,0 +1,30 @@
+iter num = 11
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	1	;JumpIfEqual 1
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		cmp	r4,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	0	;JumpIfEqual 1
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		cmp	r5,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		jmp	l2	;Jump
+use = () def = (1 )	in = ()	 	out = (1 )	 	l3 :	mov	r1,	0	;Affect
+use = () def = (6 )	in = (1 )	 	out = (1 6 )	 	l2 :	mov	r6,	1	;jumpIfNotEqual 1
+use = (6 ) def = ()	in = (1 6 )	 	out = (1 )	 		cmp	r6,	0	;on passe par un registre temporaire
+use = () def = ()	in = (1 )	 	out = (1 )	 		jne	l1	;jumpIfNotEqual 2
+use = (1 ) def = ()	in = (1 )	 	out = ()	 		cmp	r1,	0	;jumpIfNotEqual 1
+use = () def = ()	in = ()	 	out = ()	 		jne	l1	;jumpIfNotEqual 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		jmp	l0	;Jump
+use = () def = (0 )	in = ()	 	out = (0 )	 	l1 :	mov	r0,	1	;Affect
+use = (0 ) def = (7 )	in = (0 )	 	out = ()	 	l0 :	mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/rec1.fgs b/test/fgs-ref/rec1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..3ca7549d4f97cfe481d8c2a2f881ca953b7111c9
--- /dev/null
+++ b/test/fgs-ref/rec1.fgs
@@ -0,0 +1,74 @@
+iter num = 7
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = (6 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (7 )	in = ()	 	out = ()	 		mov	eax,	1	; code de sortie
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		push	eax	;sauvegarde de eax
+use = () def = ()	in = ()	 	out = ()	 		push	ebx	;sauvegarde de ebx
+use = () def = ()	in = ()	 	out = ()	 		push	ecx	;sauvegarde de ecx
+use = () def = ()	in = ()	 	out = ()	 		push	edx	;sauvegarde de edx
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		cmp	dword [ebp+12],	1	;JumpIfEqual 1
+use = () def = ()	in = (1 )	 	out = (1 )	 		je	l2	;JumpIfEqual 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l2 :	cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l0	;JumpIfEqual 2
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (12 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (13 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (14 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (15 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 		jmp	l1	;Jump
+use = () def = (3 )	in = ()	 	out = (3 )	 	l0 :	mov	r3,	dword [ebp+12]	;
+use = (3 ) def = (3 )	in = (3 )	 	out = ()	 		sub	r3,	1	;
+use = () def = ()	in = ()	 	out = ()	 		push	r3	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (2 )	in = ()	 	out = (2 )	 		pop	r2	;récupération de la valeur de retour
+use = () def = ()	in = (2 )	 	out = (2 )	 		add	esp,	4	;désallocation des arguments
+use = () def = (4 )	in = (2 )	 	out = (2 4 )	 		mov	r4,	1	;
+use = (2 4 ) def = (4 )	in = (2 4 )	 	out = (4 )	 		add	r4,	r2	;
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		mov	dword [ebp+8],	r4	;ecriture de la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (16 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (17 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (18 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (19 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	l1 :	add	esp,	0	;désallocation des variables locales
+use = () def = (20 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (21 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (22 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (23 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		push	eax	;sauvegarde de eax
+use = () def = ()	in = ()	 	out = ()	 		push	ebx	;sauvegarde de ebx
+use = () def = ()	in = ()	 	out = ()	 		push	ecx	;sauvegarde de ecx
+use = () def = ()	in = ()	 	out = ()	 		push	edx	;sauvegarde de edx
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		push	100	;Param
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (5 )	in = ()	 	out = (5 )	 		pop	r5	;récupération de la valeur de retour
+use = () def = ()	in = (5 )	 	out = (5 )	 		add	esp,	4	;désallocation des arguments
+use = (5 ) def = (28 )	in = (5 )	 	out = ()	 		mov	eax,	r5	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (29 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (30 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (31 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (32 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/si1.fgs b/test/fgs-ref/si1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d394ed05eeb802ba056c393e9c1b86ccfe845847
--- /dev/null
+++ b/test/fgs-ref/si1.fgs
@@ -0,0 +1,16 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	1	;JumpIfEqual 1
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		cmp	r2,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 	l1 :	add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/si2.fgs b/test/fgs-ref/si2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..f752f202ff887676e15a9666d6a3217296a8505d
--- /dev/null
+++ b/test/fgs-ref/si2.fgs
@@ -0,0 +1,19 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	0	;JumpIfEqual 1
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		cmp	r2,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l0	;JumpIfEqual 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		jmp	l1	;Jump
+use = () def = (4 )	in = ()	 	out = ()	 	l0 :	mov	eax,	0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 	l1 :	add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/si3.fgs b/test/fgs-ref/si3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d60ffe208ce5cfd94e1d4e0602ee0fb8b69a225c
--- /dev/null
+++ b/test/fgs-ref/si3.fgs
@@ -0,0 +1,21 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	1	;JumpIfEqual 1
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		cmp	r2,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l0	;JumpIfEqual 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		jmp	l1	;Jump
+use = () def = (4 )	in = ()	 	out = ()	 	l0 :	mov	eax,	0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (5 )	in = ()	 	out = ()	 	l1 :	mov	eax,	3	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/si4.fgs b/test/fgs-ref/si4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..8f0dfb32e517a5c1b4b81f942c6d103166b20240
--- /dev/null
+++ b/test/fgs-ref/si4.fgs
@@ -0,0 +1,21 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	0	;JumpIfEqual 1
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		cmp	r2,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l0	;JumpIfEqual 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		jmp	l1	;Jump
+use = () def = (4 )	in = ()	 	out = ()	 	l0 :	mov	eax,	0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (5 )	in = ()	 	out = ()	 	l1 :	mov	eax,	3	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/si5.fgs b/test/fgs-ref/si5.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..9f931ee449060c74b7d5a4e9b356631b1dd0bc8a
--- /dev/null
+++ b/test/fgs-ref/si5.fgs
@@ -0,0 +1,33 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	; code de sortie
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		push	eax	;sauvegarde de eax
+use = () def = ()	in = ()	 	out = ()	 		push	ebx	;sauvegarde de ebx
+use = () def = ()	in = ()	 	out = ()	 		push	ecx	;sauvegarde de ecx
+use = () def = ()	in = ()	 	out = ()	 		push	edx	;sauvegarde de edx
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (7 )	in = ()	 	out = (7 )	 		mov	r7,	1	;JumpIfEqual 1
+use = (7 ) def = ()	in = (7 )	 	out = ()	 		cmp	r7,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (8 )	in = ()	 	out = ()	 		mov	eax,	1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (9 )	in = ()	 	out = (9 )	 		mov	r9,	1	;JumpIfEqual 1
+use = (9 ) def = ()	in = (9 )	 	out = ()	 		cmp	r9,	0	;on passe par un registre temporaire
+use = () def = ()	in = ()	 	out = ()	 		je	l3	;JumpIfEqual 2
+use = () def = (10 )	in = ()	 	out = ()	 		mov	eax,	2	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (11 )	in = ()	 	out = ()	 	l3 :	mov	eax,	3	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = (12 )	in = ()	 	out = ()	 		pop	edx	;restaure edx
+use = () def = (13 )	in = ()	 	out = ()	 		pop	ecx	;restaure ecx
+use = () def = (14 )	in = ()	 	out = ()	 		pop	ebx	;restaure ebx
+use = () def = (15 )	in = ()	 	out = ()	 		pop	eax	;restaure eax
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/sub1.fgs b/test/fgs-ref/sub1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..5b3cd76ea7b44eb2f0d2e79a32f98a07e9bfa36a
--- /dev/null
+++ b/test/fgs-ref/sub1.fgs
@@ -0,0 +1,15 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	10	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		sub	r0,	5	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/sub2.fgs b/test/fgs-ref/sub2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..cec410fe23922832e4e88d695f57c6a2b43febc4
--- /dev/null
+++ b/test/fgs-ref/sub2.fgs
@@ -0,0 +1,15 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	7	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		sub	r0,	20	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/sub3.fgs b/test/fgs-ref/sub3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..95d9b3599bce1afe2d417db9768a1cc1be0be15e
--- /dev/null
+++ b/test/fgs-ref/sub3.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	2	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		sub	r0,	1	;
+use = (0 ) def = (1 )	in = (0 )	 	out = (1 )	 		mov	r1,	r0	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		sub	r1,	1	;
+use = (1 ) def = (4 )	in = (1 )	 	out = ()	 		mov	eax,	r1	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tab1.fgs b/test/fgs-ref/tab1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..231b91a430fc968b8b87a26ee703ac84272d7ac0
--- /dev/null
+++ b/test/fgs-ref/tab1.fgs
@@ -0,0 +1,26 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	0	;
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		mov	dword [tab+4*r2],	0	;Affect
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	1	;
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		mov	dword [tab+4*r3],	1	;Affect
+use = () def = (4 )	in = ()	 	out = (4 )	 		mov	r4,	2	;
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		mov	dword [tab+4*r4],	2	;Affect
+use = () def = (6 )	in = ()	 	out = (6 )	 		mov	r6,	0	;
+use = (6 ) def = (5 )	in = (6 )	 	out = ()	 		mov	eax,	dword [tab+4*r6]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (8 )	in = ()	 	out = (8 )	 		mov	r8,	1	;
+use = (8 ) def = (7 )	in = (8 )	 	out = ()	 		mov	eax,	dword [tab+4*r8]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (10 )	in = ()	 	out = (10 )	 		mov	r10,	2	;
+use = (10 ) def = (9 )	in = (10 )	 	out = ()	 		mov	eax,	dword [tab+4*r10]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tab2.fgs b/test/fgs-ref/tab2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..de80c1273167955ecd770a0e4083689cdc0ee294
--- /dev/null
+++ b/test/fgs-ref/tab2.fgs
@@ -0,0 +1,33 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (3 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	2	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [ebp-4*1]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	0	;
+use = (0 ) def = (5 )	in = (0 )	 	out = (5 )	 		mov	r5,	r0	;
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		mov	dword [tab+4*r5],	34	;Affect
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	dword [ebp-4*1]	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	1	;
+use = (1 ) def = (6 )	in = (1 )	 	out = (6 )	 		mov	r6,	r1	;
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		mov	dword [tab+4*r6],	74	;Affect
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	dword [ebp-4*1]	;
+use = (2 ) def = (2 )	in = (2 )	 	out = (2 )	 		add	r2,	2	;
+use = (2 ) def = (7 )	in = (2 )	 	out = (7 )	 		mov	r7,	r2	;
+use = (7 ) def = ()	in = (7 )	 	out = ()	 		mov	dword [tab+4*r7],	16	;Affect
+use = () def = (9 )	in = ()	 	out = (9 )	 		mov	r9,	2	;
+use = (9 ) def = (8 )	in = (9 )	 	out = ()	 		mov	eax,	dword [tab+4*r9]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (11 )	in = ()	 	out = (11 )	 		mov	r11,	3	;
+use = (11 ) def = (10 )	in = (11 )	 	out = ()	 		mov	eax,	dword [tab+4*r11]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (13 )	in = ()	 	out = (13 )	 		mov	r13,	4	;
+use = (13 ) def = (12 )	in = (13 )	 	out = ()	 		mov	eax,	dword [tab+4*r13]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tab3.fgs b/test/fgs-ref/tab3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..95adfbb99ed5c152e37d295cfecfe278d4938862
--- /dev/null
+++ b/test/fgs-ref/tab3.fgs
@@ -0,0 +1,36 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (3 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	8	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	2	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	0	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [ebp-4*1]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	dword [ebp-4*2]	;
+use = (0 ) def = (5 )	in = (0 )	 	out = (5 )	 		mov	r5,	r0	;
+use = (5 ) def = ()	in = (5 )	 	out = ()	 		mov	dword [tab+4*r5],	34	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	1	;Affect
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	dword [ebp-4*1]	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		add	r1,	dword [ebp-4*2]	;
+use = (1 ) def = (6 )	in = (1 )	 	out = (6 )	 		mov	r6,	r1	;
+use = (6 ) def = ()	in = (6 )	 	out = ()	 		mov	dword [tab+4*r6],	74	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	2	;Affect
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	dword [ebp-4*1]	;
+use = (2 ) def = (2 )	in = (2 )	 	out = (2 )	 		add	r2,	dword [ebp-4*2]	;
+use = (2 ) def = (7 )	in = (2 )	 	out = (7 )	 		mov	r7,	r2	;
+use = (7 ) def = ()	in = (7 )	 	out = ()	 		mov	dword [tab+4*r7],	16	;Affect
+use = () def = (9 )	in = ()	 	out = (9 )	 		mov	r9,	2	;
+use = (9 ) def = (8 )	in = (9 )	 	out = ()	 		mov	eax,	dword [tab+4*r9]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (11 )	in = ()	 	out = (11 )	 		mov	r11,	3	;
+use = (11 ) def = (10 )	in = (11 )	 	out = ()	 		mov	eax,	dword [tab+4*r11]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (13 )	in = ()	 	out = (13 )	 		mov	r13,	4	;
+use = (13 ) def = (12 )	in = (13 )	 	out = ()	 		mov	eax,	dword [tab+4*r13]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	8	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tab4.fgs b/test/fgs-ref/tab4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..c0d4f8ad14c4aed7f0572b184afc6af885d765a7
--- /dev/null
+++ b/test/fgs-ref/tab4.fgs
@@ -0,0 +1,30 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = (3 )	in = ()	 	out = (3 )	 		mov	r3,	0	;
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		mov	dword [tab+4*r3],	1	;Affect
+use = () def = (5 )	in = ()	 	out = (5 )	 		mov	r5,	0	;
+use = (5 ) def = (4 )	in = (5 )	 	out = (4 )	 		mov	r4,	dword [tab+4*r5]	;
+use = (4 ) def = ()	in = (4 )	 	out = ()	 		mov	dword [tab+4*r4],	12	;Affect
+use = () def = (6 )	in = ()	 	out = (6 )	 		mov	r6,	0	;
+use = (6 ) def = (0 )	in = (6 )	 	out = (0 )	 		mov	r0,	dword [tab+4*r6]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	1	;
+use = (0 ) def = (7 )	in = (0 )	 	out = (7 )	 		mov	r7,	r0	;
+use = (7 ) def = ()	in = (7 )	 	out = ()	 		mov	dword [tab+4*r7],	13	;Affect
+use = () def = (9 )	in = ()	 	out = (9 )	 		mov	r9,	0	;
+use = (9 ) def = (8 )	in = (9 )	 	out = ()	 		mov	eax,	dword [tab+4*r9]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (11 )	in = ()	 	out = (11 )	 		mov	r11,	1	;
+use = (11 ) def = (10 )	in = (11 )	 	out = ()	 		mov	eax,	dword [tab+4*r11]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (13 )	in = ()	 	out = (13 )	 		mov	r13,	2	;
+use = (13 ) def = (12 )	in = (13 )	 	out = ()	 		mov	eax,	dword [tab+4*r13]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tantque1.fgs b/test/fgs-ref/tantque1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..d7bf6e0d387e2d39e5be1a0061a2a52efc5c0cd8
--- /dev/null
+++ b/test/fgs-ref/tantque1.fgs
@@ -0,0 +1,27 @@
+iter num = 9
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (2 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	10	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 	l0 :	mov	r0,	1	;Affect
+use = () def = (4 )	in = (0 )	 	out = (0 4 )	 		mov	r4,	0	;JumpIfLess 1
+use = (4 ) def = ()	in = (0 4 )	 	out = (0 )	 		cmp	r4,	dword [ebp-4*1]	;on passe par un registre temporaire
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l2	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = ()	in = (0 )	 	out = ()	 	l2 :	cmp	r0,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = (5 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	dword [ebp-4*1]	;
+use = (1 ) def = (1 )	in = (1 )	 	out = (1 )	 		sub	r1,	1	;
+use = (1 ) def = ()	in = (1 )	 	out = ()	 		mov	dword [ebp-4*1],	r1	;Affect
+use = () def = ()	in = ()	 	out = ()	 		jmp	l0	;Jump
+use = () def = (6 )	in = ()	 	out = ()	 	l1 :	mov	eax,	0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/tantque2.fgs b/test/fgs-ref/tantque2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..279c4dfa7e0a47ec52d6ae2b1a470c5e81e695ca
--- /dev/null
+++ b/test/fgs-ref/tantque2.fgs
@@ -0,0 +1,37 @@
+iter num = 7
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (4 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (5 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	8	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	0	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 	l0 :	mov	r0,	1	;Affect
+use = () def = ()	in = (0 )	 	out = (0 )	 		cmp	dword [ebp-4*1],	4	;JumpIfLess 1
+use = () def = ()	in = (0 )	 	out = (0 )	 		jl	l2	;JumpIfLess 2
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	0	;Affect
+use = (0 ) def = ()	in = (0 )	 	out = ()	 	l2 :	cmp	r0,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l1	;JumpIfEqual 2
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	0	;Affect
+use = () def = (1 )	in = ()	 	out = (1 )	 	l3 :	mov	r1,	1	;Affect
+use = () def = ()	in = (1 )	 	out = (1 )	 		cmp	dword [ebp-4*2],	4	;JumpIfLess 1
+use = () def = ()	in = (1 )	 	out = (1 )	 		jl	l5	;JumpIfLess 2
+use = () def = (1 )	in = ()	 	out = (1 )	 		mov	r1,	0	;Affect
+use = (1 ) def = ()	in = (1 )	 	out = ()	 	l5 :	cmp	r1,	0	;JumpIfEqual 1
+use = () def = ()	in = ()	 	out = ()	 		je	l4	;JumpIfEqual 2
+use = () def = (6 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (7 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*2]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (2 )	in = ()	 	out = (2 )	 		mov	r2,	dword [ebp-4*2]	;
+use = (2 ) def = (2 )	in = (2 )	 	out = (2 )	 		add	r2,	1	;
+use = (2 ) def = ()	in = (2 )	 	out = ()	 		mov	dword [ebp-4*2],	r2	;Affect
+use = () def = ()	in = ()	 	out = ()	 		jmp	l3	;Jump
+use = () def = (3 )	in = ()	 	out = (3 )	 	l4 :	mov	r3,	dword [ebp-4*1]	;
+use = (3 ) def = (3 )	in = (3 )	 	out = (3 )	 		add	r3,	1	;
+use = (3 ) def = ()	in = (3 )	 	out = ()	 		mov	dword [ebp-4*1],	r3	;Affect
+use = () def = ()	in = ()	 	out = ()	 		jmp	l0	;Jump
+use = () def = ()	in = ()	 	out = ()	 	l1 :	add	esp,	8	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varglob1.fgs b/test/fgs-ref/varglob1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..72148c7bdc6342700cbf03de513ef3c9b0bb1083
--- /dev/null
+++ b/test/fgs-ref/varglob1.fgs
@@ -0,0 +1,14 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [variable],	6834	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [variable]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varglob2.fgs b/test/fgs-ref/varglob2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..b4190b6dbe9f8233d7fc10e522dd5bbe78a64b7b
--- /dev/null
+++ b/test/fgs-ref/varglob2.fgs
@@ -0,0 +1,16 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [variable],	10	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [variable]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	50	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varglob3.fgs b/test/fgs-ref/varglob3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..35eebac1b9fa24d0f086cd3f0bc37e5391c1119a
--- /dev/null
+++ b/test/fgs-ref/varglob3.fgs
@@ -0,0 +1,17 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [var1],	10	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [var2],	34	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [var1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [var2]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varglob4.fgs b/test/fgs-ref/varglob4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..6405a6f21615c5ceb085870025b307840d6b60fa
--- /dev/null
+++ b/test/fgs-ref/varglob4.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [var1],	10	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [var2],	34	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [var1]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	dword [var2]	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varloc1.fgs b/test/fgs-ref/varloc1.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..591bef11e8dba7b96c15557ea036110fe431ff9b
--- /dev/null
+++ b/test/fgs-ref/varloc1.fgs
@@ -0,0 +1,14 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	6834	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varloc2.fgs b/test/fgs-ref/varloc2.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..3d7d2c72751b998bf20363cb66c8e97e20479573
--- /dev/null
+++ b/test/fgs-ref/varloc2.fgs
@@ -0,0 +1,16 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	10	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [ebp-4*1]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	50	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varloc3.fgs b/test/fgs-ref/varloc3.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..e38d5724c463ef3549a0c360fa8b10f9a06ebc0b
--- /dev/null
+++ b/test/fgs-ref/varloc3.fgs
@@ -0,0 +1,17 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (0 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (1 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	8	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	10	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	30	;Affect
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*2]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	8	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varloc4.fgs b/test/fgs-ref/varloc4.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..0357bacf680ceebf6184b737536124486a4f5431
--- /dev/null
+++ b/test/fgs-ref/varloc4.fgs
@@ -0,0 +1,17 @@
+iter num = 3
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	8	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	10	;Affect
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*2],	30	;Affect
+use = () def = (0 )	in = ()	 	out = (0 )	 		mov	r0,	dword [ebp-4*1]	;
+use = (0 ) def = (0 )	in = (0 )	 	out = (0 )	 		add	r0,	dword [ebp-4*2]	;
+use = (0 ) def = (3 )	in = (0 )	 	out = ()	 		mov	eax,	r0	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	8	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/fgs-ref/varloc5.fgs b/test/fgs-ref/varloc5.fgs
new file mode 100644
index 0000000000000000000000000000000000000000..74ee639cf0e1cca87d87ac21552afc3b123a218c
--- /dev/null
+++ b/test/fgs-ref/varloc5.fgs
@@ -0,0 +1,26 @@
+iter num = 1
+use = () def = ()	in = ()	 	out = ()	 		call	main	;
+use = () def = (1 )	in = ()	 	out = ()	 		mov	ebx,	0	; valeur de retour du programme
+use = () def = (2 )	in = ()	 	out = ()	 		mov	eax,	1	;
+use = () def = ()	in = ()	 	out = ()	 		int 0x80	;
+use = () def = ()	in = ()	 	out = ()	 	f :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [ebp-4*1],	10	;Affect
+use = () def = (3 )	in = ()	 	out = ()	 		mov	eax,	dword [ebp-4*1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	4	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
+use = () def = ()	in = ()	 	out = ()	 	main :	push	ebp	;sauvegarde la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		mov	ebp,	esp	;nouvelle valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	0	;allocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		mov	dword [var1],	20	;Affect
+use = () def = ()	in = ()	 	out = ()	 		sub	esp,	4	;allocation mémoire pour la valeur de retour
+use = () def = ()	in = ()	 	out = ()	 		call	f	;
+use = () def = (0 )	in = ()	 	out = ()	 		pop	r0	;récupération de la valeur de retour
+use = () def = (4 )	in = ()	 	out = ()	 		mov	eax,	dword [var1]	;Write 1
+use = () def = ()	in = ()	 	out = ()	 		call	iprintLF	;Write 2
+use = () def = ()	in = ()	 	out = ()	 		add	esp,	0	;désallocation des variables locales
+use = () def = ()	in = ()	 	out = ()	 		pop	ebp	;restaure la valeur de ebp
+use = () def = ()	in = ()	 	out = ()	 		ret	;
diff --git a/test/ig-ref/add1.ig b/test/ig-ref/add1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/add1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/add2.ig b/test/ig-ref/add2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/add2.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/affect1.ig b/test/ig-ref/affect1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/affect1.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/affect2.ig b/test/ig-ref/affect2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/affect2.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/affect3.ig b/test/ig-ref/affect3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/affect3.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/and1.ig b/test/ig-ref/and1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/and1.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/and2.ig b/test/ig-ref/and2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/and2.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/and3.ig b/test/ig-ref/and3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/and3.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/and4.ig b/test/ig-ref/and4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/and4.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/and5.ig b/test/ig-ref/and5.ig
new file mode 100644
index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb
--- /dev/null
+++ b/test/ig-ref/and5.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
diff --git a/test/ig-ref/appel-param1.ig b/test/ig-ref/appel-param1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/appel-param1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/appel-param2.ig b/test/ig-ref/appel-param2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/appel-param2.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/appel-param3.ig b/test/ig-ref/appel-param3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb
--- /dev/null
+++ b/test/ig-ref/appel-param3.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
diff --git a/test/ig-ref/appel-retour1.ig b/test/ig-ref/appel-retour1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/appel-retour1.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/appel1.ig b/test/ig-ref/appel1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/appel1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/appel2.ig b/test/ig-ref/appel2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/appel2.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/appel3.ig b/test/ig-ref/appel3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/appel3.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/div1.ig b/test/ig-ref/div1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19
--- /dev/null
+++ b/test/ig-ref/div1.ig
@@ -0,0 +1,7 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 5 )
+5 : ( 4 )
+6 : ( )
diff --git a/test/ig-ref/div2.ig b/test/ig-ref/div2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19
--- /dev/null
+++ b/test/ig-ref/div2.ig
@@ -0,0 +1,7 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 5 )
+5 : ( 4 )
+6 : ( )
diff --git a/test/ig-ref/div3.ig b/test/ig-ref/div3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..cc8980121196af577980067b44c059fc2f0e0984
--- /dev/null
+++ b/test/ig-ref/div3.ig
@@ -0,0 +1,11 @@
+0 : ( 9 )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( 9 6 )
+6 : ( 5 9 )
+7 : ( )
+8 : ( 9 )
+9 : ( 8 0 5 6 )
+10 : ( )
diff --git a/test/ig-ref/div4.ig b/test/ig-ref/div4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19
--- /dev/null
+++ b/test/ig-ref/div4.ig
@@ -0,0 +1,7 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 5 )
+5 : ( 4 )
+6 : ( )
diff --git a/test/ig-ref/ecrire1.ig b/test/ig-ref/ecrire1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/ecrire1.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/ecrire2.ig b/test/ig-ref/ecrire2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/ecrire2.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/egal1.ig b/test/ig-ref/egal1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/egal1.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/egal2.ig b/test/ig-ref/egal2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/egal2.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/egal3.ig b/test/ig-ref/egal3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54
--- /dev/null
+++ b/test/ig-ref/egal3.ig
@@ -0,0 +1,6 @@
+0 : ( 1 )
+1 : ( 0 4 )
+2 : ( )
+3 : ( )
+4 : ( 1 )
+5 : ( )
diff --git a/test/ig-ref/err5.ig b/test/ig-ref/err5.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/err5.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/fibo.ig b/test/ig-ref/fibo.ig
new file mode 100644
index 0000000000000000000000000000000000000000..995a6d6c7c53e0bc9dade0852ee98696d6fdb389
--- /dev/null
+++ b/test/ig-ref/fibo.ig
@@ -0,0 +1,35 @@
+0 : ( )
+1 : ( )
+2 : ( 4 5 )
+3 : ( )
+4 : ( 6 2 )
+5 : ( 2 )
+6 : ( 4 )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
+14 : ( )
+15 : ( )
+16 : ( )
+17 : ( )
+18 : ( )
+19 : ( )
+20 : ( )
+21 : ( )
+22 : ( )
+23 : ( )
+24 : ( )
+25 : ( )
+26 : ( )
+27 : ( )
+28 : ( )
+29 : ( )
+30 : ( )
+31 : ( )
+32 : ( )
+33 : ( )
+34 : ( )
diff --git a/test/ig-ref/inf1.ig b/test/ig-ref/inf1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/inf1.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/inf2.ig b/test/ig-ref/inf2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/inf2.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/inf3.ig b/test/ig-ref/inf3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/inf3.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/inf4.ig b/test/ig-ref/inf4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54
--- /dev/null
+++ b/test/ig-ref/inf4.ig
@@ -0,0 +1,6 @@
+0 : ( 1 )
+1 : ( 0 4 )
+2 : ( )
+3 : ( )
+4 : ( 1 )
+5 : ( )
diff --git a/test/ig-ref/mult1.ig b/test/ig-ref/mult1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/mult1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/mult2.ig b/test/ig-ref/mult2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/mult2.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/mult3.ig b/test/ig-ref/mult3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/mult3.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/not1.ig b/test/ig-ref/not1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/not1.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/not2.ig b/test/ig-ref/not2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f
--- /dev/null
+++ b/test/ig-ref/not2.ig
@@ -0,0 +1,5 @@
+0 : ( 3 )
+1 : ( )
+2 : ( )
+3 : ( 0 )
+4 : ( )
diff --git a/test/ig-ref/not3.ig b/test/ig-ref/not3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54
--- /dev/null
+++ b/test/ig-ref/not3.ig
@@ -0,0 +1,6 @@
+0 : ( 1 )
+1 : ( 0 4 )
+2 : ( )
+3 : ( )
+4 : ( 1 )
+5 : ( )
diff --git a/test/ig-ref/or1.ig b/test/ig-ref/or1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/or1.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/or2.ig b/test/ig-ref/or2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/or2.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/or3.ig b/test/ig-ref/or3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/or3.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/or4.ig b/test/ig-ref/or4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/or4.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/or5.ig b/test/ig-ref/or5.ig
new file mode 100644
index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb
--- /dev/null
+++ b/test/ig-ref/or5.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
diff --git a/test/ig-ref/parenth1.ig b/test/ig-ref/parenth1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/parenth1.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/parenth2.ig b/test/ig-ref/parenth2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/parenth2.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/prio23-1.ig b/test/ig-ref/prio23-1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..01906f1f55c7e72f8ab7d976cf8fcc17186c563e
--- /dev/null
+++ b/test/ig-ref/prio23-1.ig
@@ -0,0 +1,6 @@
+0 : ( 4 )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 0 )
+5 : ( )
diff --git a/test/ig-ref/prio23-2.ig b/test/ig-ref/prio23-2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3c4608482365a6a21e9ccf6dc11524a3c9ce5d2f
--- /dev/null
+++ b/test/ig-ref/prio23-2.ig
@@ -0,0 +1,6 @@
+0 : ( 1 4 )
+1 : ( 0 )
+2 : ( )
+3 : ( )
+4 : ( 0 )
+5 : ( )
diff --git a/test/ig-ref/prio23-3.ig b/test/ig-ref/prio23-3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..2c85526956fe487ca5073e4bd388a8297976f676
--- /dev/null
+++ b/test/ig-ref/prio23-3.ig
@@ -0,0 +1,9 @@
+0 : ( 4 7 )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 7 0 )
+5 : ( )
+6 : ( 7 )
+7 : ( 6 4 0 )
+8 : ( )
diff --git a/test/ig-ref/prio23-4.ig b/test/ig-ref/prio23-4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..a6f011454e01399e9487896d2684cc3b60098e93
--- /dev/null
+++ b/test/ig-ref/prio23-4.ig
@@ -0,0 +1,10 @@
+0 : ( 6 1 5 8 )
+1 : ( 6 8 0 )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( 8 0 )
+6 : ( 8 1 0 )
+7 : ( )
+8 : ( 6 1 5 0 )
+9 : ( )
diff --git a/test/ig-ref/prio34-1.ig b/test/ig-ref/prio34-1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5
--- /dev/null
+++ b/test/ig-ref/prio34-1.ig
@@ -0,0 +1,5 @@
+0 : ( 1 )
+1 : ( 0 )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/prio34-2.ig b/test/ig-ref/prio34-2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/prio34-2.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/prio34-3.ig b/test/ig-ref/prio34-3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..896201f0cf276a33d3eacdda3e9efe03ece0118d
--- /dev/null
+++ b/test/ig-ref/prio34-3.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( 6 )
+6 : ( 5 )
+7 : ( )
diff --git a/test/ig-ref/prio34-4.ig b/test/ig-ref/prio34-4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..160bcbd72aa91b0df143036726fcd2a5e96bffb0
--- /dev/null
+++ b/test/ig-ref/prio34-4.ig
@@ -0,0 +1,8 @@
+0 : ( 1 )
+1 : ( 0 )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( 6 )
+6 : ( 5 )
+7 : ( )
diff --git a/test/ig-ref/prio45-1.ig b/test/ig-ref/prio45-1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3e687894c32f2e6bd4825a4c5b748f70ba2d2ab2
--- /dev/null
+++ b/test/ig-ref/prio45-1.ig
@@ -0,0 +1,6 @@
+0 : ( 4 1 )
+1 : ( 4 0 )
+2 : ( )
+3 : ( )
+4 : ( 1 0 )
+5 : ( )
diff --git a/test/ig-ref/prio45-2.ig b/test/ig-ref/prio45-2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5
--- /dev/null
+++ b/test/ig-ref/prio45-2.ig
@@ -0,0 +1,5 @@
+0 : ( 1 )
+1 : ( 0 )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/prio45-3.ig b/test/ig-ref/prio45-3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3e687894c32f2e6bd4825a4c5b748f70ba2d2ab2
--- /dev/null
+++ b/test/ig-ref/prio45-3.ig
@@ -0,0 +1,6 @@
+0 : ( 4 1 )
+1 : ( 4 0 )
+2 : ( )
+3 : ( )
+4 : ( 1 0 )
+5 : ( )
diff --git a/test/ig-ref/prio45-4.ig b/test/ig-ref/prio45-4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5
--- /dev/null
+++ b/test/ig-ref/prio45-4.ig
@@ -0,0 +1,5 @@
+0 : ( 1 )
+1 : ( 0 )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/prio56-1.ig b/test/ig-ref/prio56-1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..5a5fe88d2b8713ca0818b3216664adad7e480337
--- /dev/null
+++ b/test/ig-ref/prio56-1.ig
@@ -0,0 +1,7 @@
+0 : ( )
+1 : ( 4 )
+2 : ( )
+3 : ( )
+4 : ( 1 )
+5 : ( )
+6 : ( )
diff --git a/test/ig-ref/prio56-2.ig b/test/ig-ref/prio56-2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..70471f118d22beab077a89cbf75d2fcfaa4ba798
--- /dev/null
+++ b/test/ig-ref/prio56-2.ig
@@ -0,0 +1,7 @@
+0 : ( )
+1 : ( 5 4 )
+2 : ( )
+3 : ( )
+4 : ( 1 )
+5 : ( 1 )
+6 : ( )
diff --git a/test/ig-ref/prio67-1.ig b/test/ig-ref/prio67-1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb
--- /dev/null
+++ b/test/ig-ref/prio67-1.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
diff --git a/test/ig-ref/prio67-2.ig b/test/ig-ref/prio67-2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..2ca8a442005ac51bade93e80883a9cc18ee6adef
--- /dev/null
+++ b/test/ig-ref/prio67-2.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( 6 )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( 1 )
+7 : ( )
diff --git a/test/ig-ref/rec1.ig b/test/ig-ref/rec1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..38c4a8b116aab938ff6e5db9c416184b14668c20
--- /dev/null
+++ b/test/ig-ref/rec1.ig
@@ -0,0 +1,33 @@
+0 : ( )
+1 : ( )
+2 : ( 4 )
+3 : ( )
+4 : ( 2 )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
+14 : ( )
+15 : ( )
+16 : ( )
+17 : ( )
+18 : ( )
+19 : ( )
+20 : ( )
+21 : ( )
+22 : ( )
+23 : ( )
+24 : ( )
+25 : ( )
+26 : ( )
+27 : ( )
+28 : ( )
+29 : ( )
+30 : ( )
+31 : ( )
+32 : ( )
diff --git a/test/ig-ref/si1.ig b/test/ig-ref/si1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/si1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/si2.ig b/test/ig-ref/si2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/si2.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/si3.ig b/test/ig-ref/si3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/si3.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/si4.ig b/test/ig-ref/si4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146
--- /dev/null
+++ b/test/ig-ref/si4.ig
@@ -0,0 +1,6 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
diff --git a/test/ig-ref/si5.ig b/test/ig-ref/si5.ig
new file mode 100644
index 0000000000000000000000000000000000000000..99b007eb14bfb050424a6bc809dd2c923f84dd00
--- /dev/null
+++ b/test/ig-ref/si5.ig
@@ -0,0 +1,16 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
+14 : ( )
+15 : ( )
diff --git a/test/ig-ref/sub1.ig b/test/ig-ref/sub1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/sub1.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/sub2.ig b/test/ig-ref/sub2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/sub2.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/sub3.ig b/test/ig-ref/sub3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/sub3.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/ig-ref/tab1.ig b/test/ig-ref/tab1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..296dc402e4beb908d25e1edd7925f7f29ccff47f
--- /dev/null
+++ b/test/ig-ref/tab1.ig
@@ -0,0 +1,11 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
diff --git a/test/ig-ref/tab2.ig b/test/ig-ref/tab2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028
--- /dev/null
+++ b/test/ig-ref/tab2.ig
@@ -0,0 +1,14 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
diff --git a/test/ig-ref/tab3.ig b/test/ig-ref/tab3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028
--- /dev/null
+++ b/test/ig-ref/tab3.ig
@@ -0,0 +1,14 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
diff --git a/test/ig-ref/tab4.ig b/test/ig-ref/tab4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028
--- /dev/null
+++ b/test/ig-ref/tab4.ig
@@ -0,0 +1,14 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
+8 : ( )
+9 : ( )
+10 : ( )
+11 : ( )
+12 : ( )
+13 : ( )
diff --git a/test/ig-ref/tantque1.ig b/test/ig-ref/tantque1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..95f1f946f2e59761b04b01a0d18ef449f8df821d
--- /dev/null
+++ b/test/ig-ref/tantque1.ig
@@ -0,0 +1,7 @@
+0 : ( 4 )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( 0 )
+5 : ( )
+6 : ( )
diff --git a/test/ig-ref/tantque2.ig b/test/ig-ref/tantque2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb
--- /dev/null
+++ b/test/ig-ref/tantque2.ig
@@ -0,0 +1,8 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
+5 : ( )
+6 : ( )
+7 : ( )
diff --git a/test/ig-ref/varglob1.ig b/test/ig-ref/varglob1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/varglob1.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/varglob2.ig b/test/ig-ref/varglob2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varglob2.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varglob3.ig b/test/ig-ref/varglob3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varglob3.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varglob4.ig b/test/ig-ref/varglob4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varglob4.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varloc1.ig b/test/ig-ref/varloc1.ig
new file mode 100644
index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac
--- /dev/null
+++ b/test/ig-ref/varloc1.ig
@@ -0,0 +1,3 @@
+0 : ( )
+1 : ( )
+2 : ( )
diff --git a/test/ig-ref/varloc2.ig b/test/ig-ref/varloc2.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varloc2.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varloc3.ig b/test/ig-ref/varloc3.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varloc3.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varloc4.ig b/test/ig-ref/varloc4.ig
new file mode 100644
index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32
--- /dev/null
+++ b/test/ig-ref/varloc4.ig
@@ -0,0 +1,4 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
diff --git a/test/ig-ref/varloc5.ig b/test/ig-ref/varloc5.ig
new file mode 100644
index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06
--- /dev/null
+++ b/test/ig-ref/varloc5.ig
@@ -0,0 +1,5 @@
+0 : ( )
+1 : ( )
+2 : ( )
+3 : ( )
+4 : ( )
diff --git a/test/input/.gitignore b/test/input/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..970de746fd38aed52f8d16ed8bc89c2f8ef771f5
--- /dev/null
+++ b/test/input/.gitignore
@@ -0,0 +1,17 @@
+*\.sc
+*\.sa
+*\.saout
+*\.ts
+*\.c3a
+*\.c3aout
+*\.pre-nasm
+*\.pre-nasmout
+*\.fg
+*\.fgs
+*\.ig
+*\.nasm
+*\.nasmout
+*\.exe
+*\.exeout
+*\.out
+*\.o
diff --git a/test/input/add1.l b/test/input/add1.l
new file mode 100644
index 0000000000000000000000000000000000000000..ba8054139b94f7cae4cb2823d6ba74bf09c7c396
--- /dev/null
+++ b/test/input/add1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(3 + 10);
+}
diff --git a/test/input/add1.s b/test/input/add1.s
new file mode 100644
index 0000000000000000000000000000000000000000..e37fb3417dfdd67027603525d88fe6ed918643ce
--- /dev/null
+++ b/test/input/add1.s
@@ -0,0 +1,20 @@
+.include "io_arm.asm"
+
+
+.data
+
+.text
+.global _start
+_start:
+	bl	main	 
+	mov	r7,	#1	 //exit syscall
+	svc	#0	 //Syscall
+main :	push	{r11,r14}	 //prologue func
+	mov	r0,	#3	 
+	add	r0,	r0,	#10	 
+	push	{r7,r14}	 //Sauvegarde r7 et lr
+	mov	r7,	#4	 //Write syscall
+	svc	#0	 	//syscall
+	pop	{r7,r15}	 //Restauration de r7 et pc
+	pop	{r11,r15}	 //epilogue func
+	bx	lr
diff --git a/test/input/add2.l b/test/input/add2.l
new file mode 100644
index 0000000000000000000000000000000000000000..7f179b25a0dafae25fc1448c7e8e9be6566d0eae
--- /dev/null
+++ b/test/input/add2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 + 4 + 8);
+}
diff --git a/test/input/add2.s b/test/input/add2.s
new file mode 100644
index 0000000000000000000000000000000000000000..308cfa2b0d03c2dcbc19fcc8bcdeb75eacd739ac
--- /dev/null
+++ b/test/input/add2.s
@@ -0,0 +1,21 @@
+.include "io_arm.asm"
+
+
+.data
+
+.text
+.global _start
+_start:
+	bl	main	 
+	mov	r7,	#1	 //exit syscall
+	svc	#0	 //Syscall
+main :	push	{r11,r14}	 //prologue func
+	mov	r1,	#2	 
+	add	r1,	r1,	#4	 
+	add	r0,	r2,	#8	 
+	push	{r7,r14}	 //Sauvegarde r7 et lr
+	mov	r7,	#4	 //Write syscall
+	svc	#0	 	//syscall
+	pop	{r7,r15}	 //Restauration de r7 et pc
+	pop	{r11,r15}	 //epilogue func
+	bx	lr
diff --git a/test/input/affect1.l b/test/input/affect1.l
new file mode 100644
index 0000000000000000000000000000000000000000..cff6425361c46fc4201ec50c467136911a31df37
--- /dev/null
+++ b/test/input/affect1.l
@@ -0,0 +1,6 @@
+entier a
+main()
+{
+a = 1;
+ecrire(a);
+}
diff --git a/test/input/affect1.s b/test/input/affect1.s
new file mode 100644
index 0000000000000000000000000000000000000000..bc095811a0185d396942f0e86fe11f35e07b3dd3
--- /dev/null
+++ b/test/input/affect1.s
@@ -0,0 +1,22 @@
+.include "io_arm.asm"
+
+
+.data
+
+.global a
+a:.worda	VAR  	1	0
+
+.text
+.global _start
+_start:
+	bl	main	 
+	mov	r7,	#1	 //exit syscall
+	svc	#0	 //Syscall
+main :	push	{r11,r14}	 //prologue func
+	mov	 a,	#1	 //Affect
+	push	{r7,r14}	 //Sauvegarde r7 et lr
+	mov	r7,	#4	 //Write syscall
+	svc	#0	 	//syscall
+	pop	{r7,r15}	 //Restauration de r7 et pc
+	pop	{r11,r15}	 //epilogue func
+	bx	lr
diff --git a/test/input/affect2.l b/test/input/affect2.l
new file mode 100644
index 0000000000000000000000000000000000000000..06a3ae489044b32b1e929fbb08b9488130ddf538
--- /dev/null
+++ b/test/input/affect2.l
@@ -0,0 +1,6 @@
+main()
+entier a
+{
+a = 1;
+ecrire(a);
+}
diff --git a/test/input/affect2.s b/test/input/affect2.s
new file mode 100644
index 0000000000000000000000000000000000000000..91743b4d1d4fbffb6a48849bb5b8aaf6ae654ff0
--- /dev/null
+++ b/test/input/affect2.s
@@ -0,0 +1,19 @@
+.include "io_arm.asm"
+
+
+.data
+
+.text
+.global _start
+_start:
+	bl	main	 
+	mov	r7,	#1	 //exit syscall
+	svc	#0	 //Syscall
+main :	push	{r11,r14}	 //prologue func
+	mov	r0,	#1	 //Affect
+	push	{r7,r14}	 //Sauvegarde r7 et lr
+	mov	r7,	#4	 //Write syscall
+	svc	#0	 	//syscall
+	pop	{r7,r15}	 //Restauration de r7 et pc
+	pop	{r11,r15}	 //epilogue func
+	bx	lr
diff --git a/test/input/affect3.l b/test/input/affect3.l
new file mode 100644
index 0000000000000000000000000000000000000000..cb1da143fa8f7f0d4d329ed8ee4ca2285cf9a8ff
--- /dev/null
+++ b/test/input/affect3.l
@@ -0,0 +1,11 @@
+f(entier a)
+{
+a = 1;
+ecrire(a);
+}
+
+main()
+entier a
+{
+f(3);
+}
diff --git a/test/input/and1.l b/test/input/and1.l
new file mode 100644
index 0000000000000000000000000000000000000000..722352f47492fad418cd756be210c096a4349659
--- /dev/null
+++ b/test/input/and1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai & vrai);
+}
diff --git a/test/input/and2.l b/test/input/and2.l
new file mode 100644
index 0000000000000000000000000000000000000000..7f27e0bdcea4de004c0f890e6db8052b40d6a99d
--- /dev/null
+++ b/test/input/and2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai & faux);
+}
diff --git a/test/input/and3.l b/test/input/and3.l
new file mode 100644
index 0000000000000000000000000000000000000000..8b824bf16aab9f72185824317a4abbf0d686974c
--- /dev/null
+++ b/test/input/and3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux & vrai);
+}
diff --git a/test/input/and4.l b/test/input/and4.l
new file mode 100644
index 0000000000000000000000000000000000000000..015b9dd2986fbec9f67b1668d25a854828ba27dc
--- /dev/null
+++ b/test/input/and4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux & faux);
+}
diff --git a/test/input/and5.l b/test/input/and5.l
new file mode 100644
index 0000000000000000000000000000000000000000..b32c729a88b8933325a9c25b89f18d727b54222f
--- /dev/null
+++ b/test/input/and5.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai & faux & vrai);
+}
diff --git a/test/input/appel-param1.l b/test/input/appel-param1.l
new file mode 100644
index 0000000000000000000000000000000000000000..3856000c925142720415e13c2cb9daf25484830b
--- /dev/null
+++ b/test/input/appel-param1.l
@@ -0,0 +1,9 @@
+f(entier a)
+{
+ecrire(a);
+}
+
+main()
+{
+f(1);
+}
diff --git a/test/input/appel-param2.l b/test/input/appel-param2.l
new file mode 100644
index 0000000000000000000000000000000000000000..5278f1a08b8a8db0830aa2e83ddcaa84e1f2e1eb
--- /dev/null
+++ b/test/input/appel-param2.l
@@ -0,0 +1,10 @@
+f(entier a, entier b)
+{
+ecrire(a);
+ecrire(b);
+}
+
+main()
+{
+f(1, 456);
+}
diff --git a/test/input/appel-param3.l b/test/input/appel-param3.l
new file mode 100644
index 0000000000000000000000000000000000000000..02cbc4c8e3d17319645602ac1535739435e5b3f3
--- /dev/null
+++ b/test/input/appel-param3.l
@@ -0,0 +1,13 @@
+f(entier a, entier b, entier c, entier d, entier e)
+{
+ecrire(a);
+ecrire(b);
+ecrire(c);
+ecrire(d);
+ecrire(e);
+}
+
+main()
+{
+f(1, 2, 3, 4, 5);
+}
diff --git a/test/input/appel-retour1.l b/test/input/appel-retour1.l
new file mode 100644
index 0000000000000000000000000000000000000000..262eaa7c62b896d06801de75a38691577bd87d70
--- /dev/null
+++ b/test/input/appel-retour1.l
@@ -0,0 +1,9 @@
+entier f(entier a)
+{
+retour(a);
+}
+
+main()
+{
+ecrire(f(3712));
+}
diff --git a/test/input/appel1.l b/test/input/appel1.l
new file mode 100644
index 0000000000000000000000000000000000000000..50282cb9ea5b0f9f2fa4e3f8738087d4b7c2070b
--- /dev/null
+++ b/test/input/appel1.l
@@ -0,0 +1,9 @@
+f()
+{
+ecrire(1);
+}
+
+main()
+{
+f();
+}
diff --git a/test/input/appel2.l b/test/input/appel2.l
new file mode 100644
index 0000000000000000000000000000000000000000..a96f3aa8de328c5b9efe4fb605c6d625f3cd822e
--- /dev/null
+++ b/test/input/appel2.l
@@ -0,0 +1,15 @@
+g()
+{
+ecrire(2);
+}
+
+f()
+{
+ecrire(1);
+g();
+}
+
+main()
+{
+f();
+}
diff --git a/test/input/appel3.l b/test/input/appel3.l
new file mode 100644
index 0000000000000000000000000000000000000000..a0a511b15da5558ccded81aec6604bdef41e7fee
--- /dev/null
+++ b/test/input/appel3.l
@@ -0,0 +1,15 @@
+g()
+{
+ecrire(2);
+}
+
+f()
+{
+ecrire(1);
+}
+
+main()
+{
+f();
+g();
+}
diff --git a/test/input/clean b/test/input/clean
new file mode 100755
index 0000000000000000000000000000000000000000..9f8b584eb15bea71df6fab7556cca284af4c8cdb
--- /dev/null
+++ b/test/input/clean
@@ -0,0 +1,14 @@
+rm *.c3a
+rm *.c3aout
+rm *.exe
+rm *.fg
+rm *.fgs
+rm *.ig
+rm *.nasm
+rm *.o
+rm *.out
+rm *.pre-nasm
+rm *.sa
+rm *.saout
+rm *.sc
+rm *.ts
diff --git a/test/input/div1.l b/test/input/div1.l
new file mode 100644
index 0000000000000000000000000000000000000000..1883db14c7a48b8cbd2e83f08bf0f56f3fe4dff9
--- /dev/null
+++ b/test/input/div1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(4 / 2);
+}
diff --git a/test/input/div2.l b/test/input/div2.l
new file mode 100644
index 0000000000000000000000000000000000000000..bbf4a3a42bc930fff183929546231ab08dcaa94f
--- /dev/null
+++ b/test/input/div2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(0 / 712);
+}
diff --git a/test/input/div3.l b/test/input/div3.l
new file mode 100644
index 0000000000000000000000000000000000000000..3ba8af5d896a381c6007b7e4c18d9a9d09f83b1a
--- /dev/null
+++ b/test/input/div3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(4 / 2 / 2);
+}
diff --git a/test/input/div4.l b/test/input/div4.l
new file mode 100644
index 0000000000000000000000000000000000000000..6d7ad34caae82faf396bfd69e0a00441960e6a2e
--- /dev/null
+++ b/test/input/div4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 / 3);
+}
diff --git a/test/input/ecrire1.l b/test/input/ecrire1.l
new file mode 100644
index 0000000000000000000000000000000000000000..fb46c6305b643f5995cc1c1cb851af461d34de3f
--- /dev/null
+++ b/test/input/ecrire1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(3456);
+}
diff --git a/test/input/ecrire2.l b/test/input/ecrire2.l
new file mode 100644
index 0000000000000000000000000000000000000000..04a17b45b509056170ac3664a8e3a335b4a2b549
--- /dev/null
+++ b/test/input/ecrire2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(0);
+}
diff --git a/test/input/egal1.l b/test/input/egal1.l
new file mode 100644
index 0000000000000000000000000000000000000000..db5eb0dee0c1e9f1ba4cf4156d5e2e64f4a20da6
--- /dev/null
+++ b/test/input/egal1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(123 = 123);
+}
diff --git a/test/input/egal2.l b/test/input/egal2.l
new file mode 100644
index 0000000000000000000000000000000000000000..c6df09c5b82d6e2ab79f25d1c2593ba7413a7be4
--- /dev/null
+++ b/test/input/egal2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(412 = 34);
+}
diff --git a/test/input/egal3.l b/test/input/egal3.l
new file mode 100644
index 0000000000000000000000000000000000000000..af9619535c4c0f005533127b010481f95afe771c
--- /dev/null
+++ b/test/input/egal3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 = 2 = vrai);
+}
diff --git a/test/input/fibo.l b/test/input/fibo.l
new file mode 100644
index 0000000000000000000000000000000000000000..f67922d1d7a91db785e6f240983a44174d93b51f
--- /dev/null
+++ b/test/input/fibo.l
@@ -0,0 +1,14 @@
+entier fibo( entier n ) 
+{
+  si n < 2 alors {
+    retour 1;
+  }
+  sinon {
+    retour fibo( n - 1 ) + fibo( n - 2 );
+  }
+}
+
+main()
+{
+  ecrire( fibo( 9 ) );
+}
diff --git a/test/input/inf1.l b/test/input/inf1.l
new file mode 100644
index 0000000000000000000000000000000000000000..57528bdd1e25e511e1d407cac927fcadd1883c1e
--- /dev/null
+++ b/test/input/inf1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(3 < 3);
+}
diff --git a/test/input/inf2.l b/test/input/inf2.l
new file mode 100644
index 0000000000000000000000000000000000000000..23255bc15203d4511ff91e0e991ff4f5d6a2ef79
--- /dev/null
+++ b/test/input/inf2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(4 < 1);
+}
diff --git a/test/input/inf3.l b/test/input/inf3.l
new file mode 100644
index 0000000000000000000000000000000000000000..dbb6666c0fcaae08017df3bbff29024f3f294ad5
--- /dev/null
+++ b/test/input/inf3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(312 < 475);
+}
diff --git a/test/input/mult1.l b/test/input/mult1.l
new file mode 100644
index 0000000000000000000000000000000000000000..1d0e8ff621b28023d4bd4ffd0ac92fbf63d12455
--- /dev/null
+++ b/test/input/mult1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 * 3);
+}
diff --git a/test/input/mult2.l b/test/input/mult2.l
new file mode 100644
index 0000000000000000000000000000000000000000..06428e506955a94984078e117342b9daa03d29aa
--- /dev/null
+++ b/test/input/mult2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(0 * 321);
+}
diff --git a/test/input/mult3.l b/test/input/mult3.l
new file mode 100644
index 0000000000000000000000000000000000000000..6f25bfea008b424fd1fd4199eaf4d0a09889596b
--- /dev/null
+++ b/test/input/mult3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(3 * 3 * 2);
+}
diff --git a/test/input/nettoie.sh b/test/input/nettoie.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e997393a9282fa28b992ded4d4943d66e5378c2b
--- /dev/null
+++ b/test/input/nettoie.sh
@@ -0,0 +1,16 @@
+rm *.c3a
+rm *.c3aout
+rm *.exe
+rm *.exeout
+rm *.fg
+rm *.fgs
+rm *.ig
+rm *.nasm
+rm *.nasmout
+rm *.o
+rm *.pre-nasm
+rm *.pre-nasmout
+rm *.sa
+rm *.saout
+rm *.sc
+rm *.ts
diff --git a/test/input/not1.l b/test/input/not1.l
new file mode 100644
index 0000000000000000000000000000000000000000..6508335f9b4a97149d484c5cd2fe3d14c601c0b7
--- /dev/null
+++ b/test/input/not1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(! vrai);
+}
diff --git a/test/input/not2.l b/test/input/not2.l
new file mode 100644
index 0000000000000000000000000000000000000000..fee01552a8624a360e162f06c033b11275e572e8
--- /dev/null
+++ b/test/input/not2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(! faux);
+}
diff --git a/test/input/not3.l b/test/input/not3.l
new file mode 100644
index 0000000000000000000000000000000000000000..e26acb5da1418f022d4984990c5e0bd02d6c9da0
--- /dev/null
+++ b/test/input/not3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(! ! faux);
+}
diff --git a/test/input/or1.l b/test/input/or1.l
new file mode 100644
index 0000000000000000000000000000000000000000..de6482ad6e2f2a7cea47f2e91723b0adbf14f65c
--- /dev/null
+++ b/test/input/or1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai | vrai);
+}
diff --git a/test/input/or2.l b/test/input/or2.l
new file mode 100644
index 0000000000000000000000000000000000000000..5c16db11ba7dd330a4afa8df1d9e8d1196defa17
--- /dev/null
+++ b/test/input/or2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai | faux);
+}
diff --git a/test/input/or3.l b/test/input/or3.l
new file mode 100644
index 0000000000000000000000000000000000000000..990b4aa6037576cad8fc371d6678fe9fb5d0a377
--- /dev/null
+++ b/test/input/or3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux | vrai);
+}
diff --git a/test/input/or4.l b/test/input/or4.l
new file mode 100644
index 0000000000000000000000000000000000000000..96e588b628266830e81c917594c41a7230587882
--- /dev/null
+++ b/test/input/or4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux | faux);
+}
diff --git a/test/input/or5.l b/test/input/or5.l
new file mode 100644
index 0000000000000000000000000000000000000000..be6b474b28f6ad7569125e178d97ab1b1d75254c
--- /dev/null
+++ b/test/input/or5.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux | vrai | faux);
+}
diff --git a/test/input/parenth1.l b/test/input/parenth1.l
new file mode 100644
index 0000000000000000000000000000000000000000..358d5254faff63203e30624944fde93eefccde66
--- /dev/null
+++ b/test/input/parenth1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((1));
+}
diff --git a/test/input/parenth2.l b/test/input/parenth2.l
new file mode 100644
index 0000000000000000000000000000000000000000..fd2f9979803761e97e6e99caa482615c375559eb
--- /dev/null
+++ b/test/input/parenth2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(((2)));
+}
diff --git a/test/input/prio34-1.l b/test/input/prio34-1.l
new file mode 100644
index 0000000000000000000000000000000000000000..3980bbf8afab5f07d2d0d1f123f1bb85bafadbe3
--- /dev/null
+++ b/test/input/prio34-1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 + 3 * 4);
+}
diff --git a/test/input/prio34-2.l b/test/input/prio34-2.l
new file mode 100644
index 0000000000000000000000000000000000000000..4ff044729bc9287225e3f905a50c4e0abfb37db6
--- /dev/null
+++ b/test/input/prio34-2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 * 3 - 4);
+}
diff --git a/test/input/prio34-3.l b/test/input/prio34-3.l
new file mode 100644
index 0000000000000000000000000000000000000000..d6c28383e98f616553c0944e167f36586d72c58d
--- /dev/null
+++ b/test/input/prio34-3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(6 / 3 - 72);
+}
diff --git a/test/input/prio34-4.l b/test/input/prio34-4.l
new file mode 100644
index 0000000000000000000000000000000000000000..943c3979a5c4dd122f4d9b643b9a18928db56148
--- /dev/null
+++ b/test/input/prio34-4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(6 + 20 / 10);
+}
diff --git a/test/input/prio45-1.l b/test/input/prio45-1.l
new file mode 100644
index 0000000000000000000000000000000000000000..126e9fb0eef9e1c071f6349a91d9c708af648349
--- /dev/null
+++ b/test/input/prio45-1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 = 0 + 1);
+}
diff --git a/test/input/prio45-2.l b/test/input/prio45-2.l
new file mode 100644
index 0000000000000000000000000000000000000000..66fe6fd16fb1a473ffd7973d83429141de85c41b
--- /dev/null
+++ b/test/input/prio45-2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 + 234 = 1);
+}
diff --git a/test/input/prio45-3.l b/test/input/prio45-3.l
new file mode 100644
index 0000000000000000000000000000000000000000..5adb3a75e291a172cf957133fdf18362a3e4ca29
--- /dev/null
+++ b/test/input/prio45-3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(12 <  11 + 100);
+}
diff --git a/test/input/prio45-4.l b/test/input/prio45-4.l
new file mode 100644
index 0000000000000000000000000000000000000000..4e5398f44d6fcb60c48a58467536a16fbacec591
--- /dev/null
+++ b/test/input/prio45-4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(21 -  21 < 1);
+}
diff --git a/test/input/prio56-1.l b/test/input/prio56-1.l
new file mode 100644
index 0000000000000000000000000000000000000000..62a43542048756e4f64e35953998f7034076709f
--- /dev/null
+++ b/test/input/prio56-1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 = 2 & vrai);
+}
diff --git a/test/input/prio56-2.l b/test/input/prio56-2.l
new file mode 100644
index 0000000000000000000000000000000000000000..83f2ec7b003eff6a6be6592f1fdc88285de2d832
--- /dev/null
+++ b/test/input/prio56-2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai | faux = vrai);
+}
diff --git a/test/input/prio67-1.l b/test/input/prio67-1.l
new file mode 100644
index 0000000000000000000000000000000000000000..6ef5a73c8a48ba9b1c025a43d66162f78645357e
--- /dev/null
+++ b/test/input/prio67-1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(faux & vrai | vrai);
+}
diff --git a/test/input/prio67-2.l b/test/input/prio67-2.l
new file mode 100644
index 0000000000000000000000000000000000000000..d35a1a0bf95ffefee72849531255791ef326e024
--- /dev/null
+++ b/test/input/prio67-2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai | vrai & faux);
+}
diff --git a/test/input/rec1.l b/test/input/rec1.l
new file mode 100644
index 0000000000000000000000000000000000000000..aad2b968a278e933899e6b6e54736e185343f44d
--- /dev/null
+++ b/test/input/rec1.l
@@ -0,0 +1,14 @@
+entier f(entier a)
+{
+si (a = 1) alors {
+retour(1);
+}
+sinon{
+retour(1 + f(a-1));
+}
+}
+
+main()
+{
+ecrire(f(100));
+}
diff --git a/test/input/si1.l b/test/input/si1.l
new file mode 100644
index 0000000000000000000000000000000000000000..e722414197395110630a5f1a8f900c0d0a89bfd9
--- /dev/null
+++ b/test/input/si1.l
@@ -0,0 +1,6 @@
+main()
+{
+si (vrai) alors {
+ecrire(vrai);
+}
+}
diff --git a/test/input/si2.l b/test/input/si2.l
new file mode 100644
index 0000000000000000000000000000000000000000..e607615f0d31bbc7132b6cb85261cd683a5ea7df
--- /dev/null
+++ b/test/input/si2.l
@@ -0,0 +1,9 @@
+main()
+{
+si (faux) alors {
+ecrire(1);
+}
+sinon{
+ecrire(0);
+}
+}
diff --git a/test/input/si3.l b/test/input/si3.l
new file mode 100644
index 0000000000000000000000000000000000000000..1872b14f0e0d43036aaaddb3f3c6e60fef197704
--- /dev/null
+++ b/test/input/si3.l
@@ -0,0 +1,10 @@
+main()
+{
+si (vrai) alors {
+ecrire(vrai);
+}
+sinon{
+ecrire(faux);
+}
+ecrire(vrai);
+}
diff --git a/test/input/si4.l b/test/input/si4.l
new file mode 100644
index 0000000000000000000000000000000000000000..5fe6f1b7a630ba6638da3a6925460ecd8112acc1
--- /dev/null
+++ b/test/input/si4.l
@@ -0,0 +1,10 @@
+main()
+{
+si (faux) alors {
+ecrire(vrai);
+}
+sinon{
+ecrire(faux);
+}
+ecrire(vrai);
+}
diff --git a/test/input/si5.l b/test/input/si5.l
new file mode 100644
index 0000000000000000000000000000000000000000..d3c57595713f40267791ddb92485f79a0e497597
--- /dev/null
+++ b/test/input/si5.l
@@ -0,0 +1,13 @@
+main()
+{
+  si (vrai) alors
+  {
+    ecrire(vrai);
+    si (vrai) alors
+    {
+      ecrire(vrai);
+    }
+  }
+  ecrire(vrai);
+}
+
diff --git a/test/input/sub1.l b/test/input/sub1.l
new file mode 100644
index 0000000000000000000000000000000000000000..32394ae9aa2f966245b8949731e6ac949e870fbc
--- /dev/null
+++ b/test/input/sub1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(10 - 5);
+}
diff --git a/test/input/sub2.l b/test/input/sub2.l
new file mode 100644
index 0000000000000000000000000000000000000000..6733990e9d10808ee504f0e581faa0c78225f2ee
--- /dev/null
+++ b/test/input/sub2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(7 - 20);
+}
diff --git a/test/input/sub3.l b/test/input/sub3.l
new file mode 100644
index 0000000000000000000000000000000000000000..e37d95503f418011c5ba69c9f9172645af3761d2
--- /dev/null
+++ b/test/input/sub3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(2 - 1 - 1);
+}
diff --git a/test/input/tab1.l b/test/input/tab1.l
new file mode 100644
index 0000000000000000000000000000000000000000..ebaf73fec0d63e6b5bf185890e2fc2a5b910138a
--- /dev/null
+++ b/test/input/tab1.l
@@ -0,0 +1,10 @@
+entier tab[3]
+main()
+{
+tab[0] = 0;
+tab[1] = 1;
+tab[2] = 2;
+ecrire(tab[0]);
+ecrire(tab[1]);
+ecrire(tab[2]);
+}
diff --git a/test/input/tab2.l b/test/input/tab2.l
new file mode 100644
index 0000000000000000000000000000000000000000..dcb20bda39a00a965361444100e9e0fef2b5de42
--- /dev/null
+++ b/test/input/tab2.l
@@ -0,0 +1,12 @@
+entier tab[5]
+main()
+entier base
+{
+base = 2;
+tab[base + 0] = 34;
+tab[base + 1] = 74;
+tab[base + 2] = 16;
+ecrire(tab[2]);
+ecrire(tab[3]);
+ecrire(tab[4]);
+}
diff --git a/test/input/tab3.l b/test/input/tab3.l
new file mode 100644
index 0000000000000000000000000000000000000000..aecacad7f8b601e4adecd6b0c2762bc021e9a39c
--- /dev/null
+++ b/test/input/tab3.l
@@ -0,0 +1,15 @@
+entier tab[5]
+main()
+entier base, entier offset
+{
+base = 2;
+offset = 0;
+tab[base + offset] = 34;
+offset = 1;
+tab[base + offset] = 74;
+offset = 2;
+tab[base + offset] = 16;
+ecrire(tab[2]);
+ecrire(tab[3]);
+ecrire(tab[4]);
+}
diff --git a/test/input/tab4.l b/test/input/tab4.l
new file mode 100644
index 0000000000000000000000000000000000000000..1a41cba1517cc02fb8c845e6dd7b20616f336e50
--- /dev/null
+++ b/test/input/tab4.l
@@ -0,0 +1,10 @@
+entier tab[3]
+main()
+{
+tab[0] = 1;
+tab[tab[0]] = 12;
+tab[tab[0]+1] = 13;
+ecrire(tab[0]);
+ecrire(tab[1]);
+ecrire(tab[2]);
+}
diff --git a/test/input/tantque1.l b/test/input/tantque1.l
new file mode 100644
index 0000000000000000000000000000000000000000..4af77aa7fcdfe268f879a39103a0fccf788458a7
--- /dev/null
+++ b/test/input/tantque1.l
@@ -0,0 +1,10 @@
+main()
+entier a
+{
+a = 10;
+tantque (0 < a) faire {
+ecrire(a);
+a = a - 1;
+}
+ecrire(0);
+}
diff --git a/test/input/tantque2.l b/test/input/tantque2.l
new file mode 100644
index 0000000000000000000000000000000000000000..4b1c59c16288e4211167a7e8a357b2c5ca256a81
--- /dev/null
+++ b/test/input/tantque2.l
@@ -0,0 +1,14 @@
+main()
+  entier a, entier b
+  {
+  a = 0;
+  tantque (a < 4) faire {
+    b = 0;
+    tantque (b < 4) faire {
+      ecrire(a);
+      ecrire(b);
+      b = b + 1;
+    }
+    a = a + 1;
+  }
+}
diff --git a/test/input/tri.l b/test/input/tri.l
new file mode 100644
index 0000000000000000000000000000000000000000..ea46356e42c22269996d59b5092f98f555c68661
--- /dev/null
+++ b/test/input/tri.l
@@ -0,0 +1,57 @@
+entier tab[ 10 ]
+
+initialiser()
+{
+    tab[0] = 8;    tab[1] = 6;    tab[2] = 9;
+    tab[3] = 9;    tab[4] = 4;    tab[5] = 2;
+    tab[6] = 3;    tab[7] = 1;    tab[8] = 4;
+    tab[9] = 5;    
+}
+
+afficher( entier n )
+entier i
+{
+    i = 0;
+    tantque i < n faire {
+        ecrire( tab[ i ] );
+        i = i + 1;
+    }    
+    ecrire( 0 ); # marqueur fin de tableau         
+}
+
+echanger( entier i, entier j )
+entier temp
+{
+    temp = tab[ j ];
+    tab[ j ] = tab[ i ];
+    tab[ i ] = temp;
+}
+
+trier( entier n )
+entier echange, entier j, entier m
+{
+    m = n;
+    echange = 1;
+    tantque echange = 1 faire
+    {
+        echange = 0;
+        j = 0;
+        tantque j < m - 1 faire 
+        {
+            si tab[ j + 1 ] < tab[ j ] alors {
+                echanger( j, j + 1 );
+                echange = 1;
+            }
+            j = j + 1;
+        }
+        m = m - 1;        
+    }    
+}
+
+main()
+{
+    initialiser();
+    afficher( 10 );
+    trier( 10 );
+    afficher( 10 );
+}
diff --git a/test/input/varglob1.l b/test/input/varglob1.l
new file mode 100644
index 0000000000000000000000000000000000000000..c8dc7affb0bdf7fc533136e47b61a4e79e0839de
--- /dev/null
+++ b/test/input/varglob1.l
@@ -0,0 +1,6 @@
+entier variable
+main()
+{
+variable = 6834;
+ecrire(variable);
+}
diff --git a/test/input/varglob2.l b/test/input/varglob2.l
new file mode 100644
index 0000000000000000000000000000000000000000..30f2aad361a62bdd23ca5eb8b408b741312ced59
--- /dev/null
+++ b/test/input/varglob2.l
@@ -0,0 +1,6 @@
+entier variable
+main()
+{
+variable = 10;
+ecrire(variable + 50 );
+}
diff --git a/test/input/varglob3.l b/test/input/varglob3.l
new file mode 100644
index 0000000000000000000000000000000000000000..8211c240806500f7e886e1cfcf07180d8c9e0313
--- /dev/null
+++ b/test/input/varglob3.l
@@ -0,0 +1,8 @@
+entier var1, entier var2
+main()
+{
+var1 = 10;
+var2 = 34;
+ecrire(var1);
+ecrire(var2);
+}
diff --git a/test/input/varglob4.l b/test/input/varglob4.l
new file mode 100644
index 0000000000000000000000000000000000000000..fa170c9b3499af2b25be20570a7a736dcd4d37cb
--- /dev/null
+++ b/test/input/varglob4.l
@@ -0,0 +1,7 @@
+entier var1, entier var2
+main()
+{
+var1 = 10;
+var2 = 34;
+ecrire(var1 + var2);
+}
diff --git a/test/input/varloc1.l b/test/input/varloc1.l
new file mode 100644
index 0000000000000000000000000000000000000000..babef23bbb8c6d64e8dfdacb0664752a5081e6df
--- /dev/null
+++ b/test/input/varloc1.l
@@ -0,0 +1,6 @@
+main()
+entier variable
+{
+variable = 6834;
+ecrire(variable);
+}
diff --git a/test/input/varloc2.l b/test/input/varloc2.l
new file mode 100644
index 0000000000000000000000000000000000000000..7899e0897ad8243c54fb5950ddb8d178edabb1a3
--- /dev/null
+++ b/test/input/varloc2.l
@@ -0,0 +1,6 @@
+main()
+entier variable
+{
+variable = 10;
+ecrire(variable + 50 );
+}
diff --git a/test/input/varloc3.l b/test/input/varloc3.l
new file mode 100644
index 0000000000000000000000000000000000000000..34125a021421208cd13b9f2fe2ddda901146fac4
--- /dev/null
+++ b/test/input/varloc3.l
@@ -0,0 +1,8 @@
+main()
+entier var1, entier var2
+{
+var1 = 10;
+var2 = 30;
+ecrire(var1);
+ecrire(var2);
+}
diff --git a/test/input/varloc4.l b/test/input/varloc4.l
new file mode 100644
index 0000000000000000000000000000000000000000..5b315ab9fee69b56301ff7d5e7b31f83174fb5f6
--- /dev/null
+++ b/test/input/varloc4.l
@@ -0,0 +1,7 @@
+main()
+entier var1, entier var2
+{
+var1 = 10;
+var2 = 30;
+ecrire(var1 + var2);
+}
diff --git a/test/input/varloc5.l b/test/input/varloc5.l
new file mode 100644
index 0000000000000000000000000000000000000000..d595344d09ef079d2ca2e85b5b58d6b82a0fae9b
--- /dev/null
+++ b/test/input/varloc5.l
@@ -0,0 +1,15 @@
+entier var1
+
+f()
+entier var1
+{
+var1 = 10;
+ecrire(var1);
+}
+
+main()
+{
+var1 = 20;
+f();
+ecrire(var1);
+}
diff --git a/test/input_err_ts/double_dec1.l b/test/input_err_ts/double_dec1.l
new file mode 100644
index 0000000000000000000000000000000000000000..5f55b854b2ff493f5a31f3cdebb21898b8cfe994
--- /dev/null
+++ b/test/input_err_ts/double_dec1.l
@@ -0,0 +1,4 @@
+entier a, bool a
+main(){
+
+}
diff --git a/test/input_err_ts/double_dec2.l b/test/input_err_ts/double_dec2.l
new file mode 100644
index 0000000000000000000000000000000000000000..39291334a850f7c729dc042a4298b970c15ac251
--- /dev/null
+++ b/test/input_err_ts/double_dec2.l
@@ -0,0 +1,4 @@
+entier a, bool a[10]
+main(){
+
+}
diff --git a/test/input_err_ts/double_dec3.l b/test/input_err_ts/double_dec3.l
new file mode 100644
index 0000000000000000000000000000000000000000..bb9b7e37c215ab4b7ec29370357ef241935c10f6
--- /dev/null
+++ b/test/input_err_ts/double_dec3.l
@@ -0,0 +1,7 @@
+f(entier a)
+entier a
+{
+}
+main(){
+
+}
diff --git a/test/input_err_ts/double_dec4.l b/test/input_err_ts/double_dec4.l
new file mode 100644
index 0000000000000000000000000000000000000000..36d911cc09a351eafa034c5ca862ccfd12eb41f6
--- /dev/null
+++ b/test/input_err_ts/double_dec4.l
@@ -0,0 +1,10 @@
+f(entier a)
+{
+}
+
+f(entier b)
+{
+}
+main(){
+
+}
diff --git a/test/input_err_ts/fct_inconnue1.l b/test/input_err_ts/fct_inconnue1.l
new file mode 100644
index 0000000000000000000000000000000000000000..f1a39929695525f8989fa3681ec364d918642f84
--- /dev/null
+++ b/test/input_err_ts/fct_inconnue1.l
@@ -0,0 +1,3 @@
+main(){
+f(2);
+}
diff --git a/test/input_err_ts/mauvais_nb_arg1.l b/test/input_err_ts/mauvais_nb_arg1.l
new file mode 100644
index 0000000000000000000000000000000000000000..72819105f7a0c9f797d70611e6dc1d3794d754a8
--- /dev/null
+++ b/test/input_err_ts/mauvais_nb_arg1.l
@@ -0,0 +1,7 @@
+entier f(entier a, entier b)
+{
+}
+
+main(){
+f(2);
+}
diff --git a/test/input_err_ts/var_inconnue1.l b/test/input_err_ts/var_inconnue1.l
new file mode 100644
index 0000000000000000000000000000000000000000..5257ff81e6bb1acc84edc60b14a6756e260a94da
--- /dev/null
+++ b/test/input_err_ts/var_inconnue1.l
@@ -0,0 +1,3 @@
+main(){
+a = 1;
+}
diff --git a/test/input_err_type/add1.l b/test/input_err_type/add1.l
new file mode 100644
index 0000000000000000000000000000000000000000..a030276253b6d71647515145a1631794aa094f4a
--- /dev/null
+++ b/test/input_err_type/add1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 + vrai);
+}
diff --git a/test/input_err_type/add2.l b/test/input_err_type/add2.l
new file mode 100644
index 0000000000000000000000000000000000000000..b96ee726d846d4eb26a6fe85aad07702341eba53
--- /dev/null
+++ b/test/input_err_type/add2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai + 1);
+}
diff --git a/test/input_err_type/add3.l b/test/input_err_type/add3.l
new file mode 100644
index 0000000000000000000000000000000000000000..93bcee1a35f94b263734a8676eabb5e7e819382f
--- /dev/null
+++ b/test/input_err_type/add3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai + faux);
+}
diff --git a/test/input_err_type/add4.l b/test/input_err_type/add4.l
new file mode 100644
index 0000000000000000000000000000000000000000..e71571e72e7f010b8d605c4f7355bab7a2c42a6b
--- /dev/null
+++ b/test/input_err_type/add4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(!(1 + 1));
+}
diff --git a/test/input_err_type/affect1.l b/test/input_err_type/affect1.l
new file mode 100644
index 0000000000000000000000000000000000000000..0a0a6928a3ed89d66e5bf28b8951aee76d150b06
--- /dev/null
+++ b/test/input_err_type/affect1.l
@@ -0,0 +1,5 @@
+entier a
+main()
+{
+a = vrai;
+}
diff --git a/test/input_err_type/affect2.l b/test/input_err_type/affect2.l
new file mode 100644
index 0000000000000000000000000000000000000000..b9b85863d01451559074e751877d36cfdf5f172a
--- /dev/null
+++ b/test/input_err_type/affect2.l
@@ -0,0 +1,5 @@
+bool a
+main()
+{
+a = 1;
+}
diff --git a/test/input_err_type/affect3.l b/test/input_err_type/affect3.l
new file mode 100644
index 0000000000000000000000000000000000000000..4ce9a7bd7e4c0934e2304679cf465fe1b3b42739
--- /dev/null
+++ b/test/input_err_type/affect3.l
@@ -0,0 +1,5 @@
+entier t[1]
+main()
+{
+t[1] = vrai;
+}
diff --git a/test/input_err_type/affect4.l b/test/input_err_type/affect4.l
new file mode 100644
index 0000000000000000000000000000000000000000..d2791d881a66b60c122851577591373091998a0b
--- /dev/null
+++ b/test/input_err_type/affect4.l
@@ -0,0 +1,5 @@
+bool t[1]
+main()
+{
+t[1] = 1;
+}
diff --git a/test/input_err_type/and1.l b/test/input_err_type/and1.l
new file mode 100644
index 0000000000000000000000000000000000000000..3dccb993e21cc8114cd7a710b071483c7f3c5cf6
--- /dev/null
+++ b/test/input_err_type/and1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai & 1);
+}
diff --git a/test/input_err_type/and2.l b/test/input_err_type/and2.l
new file mode 100644
index 0000000000000000000000000000000000000000..b42f40a1ba6b52bc0d827bd244bee8df407b87e9
--- /dev/null
+++ b/test/input_err_type/and2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 & vrai);
+}
diff --git a/test/input_err_type/and3.l b/test/input_err_type/and3.l
new file mode 100644
index 0000000000000000000000000000000000000000..3444bc0d755f2f2cda380a1daaef608a31c9da10
--- /dev/null
+++ b/test/input_err_type/and3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 & 1);
+}
diff --git a/test/input_err_type/and4.l b/test/input_err_type/and4.l
new file mode 100644
index 0000000000000000000000000000000000000000..21f7fc286c9e61bdbd73e2f782d90d4343201fde
--- /dev/null
+++ b/test/input_err_type/and4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((vrai & vrai) + 1);
+}
diff --git a/test/input_err_type/appel1.l b/test/input_err_type/appel1.l
new file mode 100644
index 0000000000000000000000000000000000000000..4c912228e2c453a9f6211529e420c81b699a2269
--- /dev/null
+++ b/test/input_err_type/appel1.l
@@ -0,0 +1,8 @@
+entier f(entier a)
+{
+}
+
+main()
+{
+f(vrai);
+}
diff --git a/test/input_err_type/appel2.l b/test/input_err_type/appel2.l
new file mode 100644
index 0000000000000000000000000000000000000000..196542bb04a4c3a9c51255c39b573c0cc8f64ec0
--- /dev/null
+++ b/test/input_err_type/appel2.l
@@ -0,0 +1,8 @@
+bool f(bool a)
+{
+}
+
+main()
+{
+f(1);
+}
diff --git a/test/input_err_type/appel3.l b/test/input_err_type/appel3.l
new file mode 100644
index 0000000000000000000000000000000000000000..f4254ae26143dfd57a491e731cdc1a0039ddd34a
--- /dev/null
+++ b/test/input_err_type/appel3.l
@@ -0,0 +1,8 @@
+bool f(bool a, bool b)
+{
+}
+
+main()
+{
+f(vrai, 1);
+}
diff --git a/test/input_err_type/appel4.l b/test/input_err_type/appel4.l
new file mode 100644
index 0000000000000000000000000000000000000000..2ccd99f24fb05dcfbbc853bfbf3c86416e4bdc44
--- /dev/null
+++ b/test/input_err_type/appel4.l
@@ -0,0 +1,8 @@
+bool f(entier a, entier b)
+{
+}
+
+main()
+{
+f(1, faux);
+}
diff --git a/test/input_err_type/div1.l b/test/input_err_type/div1.l
new file mode 100644
index 0000000000000000000000000000000000000000..321b3c8e99f55165afa1fe35b30a24d85734cb68
--- /dev/null
+++ b/test/input_err_type/div1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 / vrai);
+}
diff --git a/test/input_err_type/div2.l b/test/input_err_type/div2.l
new file mode 100644
index 0000000000000000000000000000000000000000..10e5ab357a1427f8aa1c7158f083c14a43477092
--- /dev/null
+++ b/test/input_err_type/div2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai / 1);
+}
diff --git a/test/input_err_type/div3.l b/test/input_err_type/div3.l
new file mode 100644
index 0000000000000000000000000000000000000000..5bc1aabaa4c6ff93ee637abb89d899c56aea3731
--- /dev/null
+++ b/test/input_err_type/div3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai / faux);
+}
diff --git a/test/input_err_type/div4.l b/test/input_err_type/div4.l
new file mode 100644
index 0000000000000000000000000000000000000000..f9b3c30363ed463a38905bcab806904e4a87586f
--- /dev/null
+++ b/test/input_err_type/div4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(!(1 / 1));
+}
diff --git a/test/input_err_type/egal1.l b/test/input_err_type/egal1.l
new file mode 100644
index 0000000000000000000000000000000000000000..bcbc76663e7966fb082165b0943ba5d22514a173
--- /dev/null
+++ b/test/input_err_type/egal1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 = vrai);
+}
diff --git a/test/input_err_type/egal2.l b/test/input_err_type/egal2.l
new file mode 100644
index 0000000000000000000000000000000000000000..e33cf97884677de82d6b098be06c440100da314e
--- /dev/null
+++ b/test/input_err_type/egal2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai = 1);
+}
diff --git a/test/input_err_type/egal3.l b/test/input_err_type/egal3.l
new file mode 100644
index 0000000000000000000000000000000000000000..923e15de5b8ebeb3c7248cd505de8c00e1951002
--- /dev/null
+++ b/test/input_err_type/egal3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((1 = 1) + 1);
+}
diff --git a/test/input_err_type/egal3.nasm b/test/input_err_type/egal3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..9e9eac4d4bec6dc975db3f9e50212792d3d3666d
--- /dev/null
+++ b/test/input_err_type/egal3.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/input_err_type/inf1.l b/test/input_err_type/inf1.l
new file mode 100644
index 0000000000000000000000000000000000000000..80b0a60d28d4a71b14ef9204cf28c5ad7cf5e852
--- /dev/null
+++ b/test/input_err_type/inf1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 < vrai);
+}
diff --git a/test/input_err_type/inf2.l b/test/input_err_type/inf2.l
new file mode 100644
index 0000000000000000000000000000000000000000..28ce301b45cdd6b13fcaa4a1f45786e07db1c265
--- /dev/null
+++ b/test/input_err_type/inf2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai < 1);
+}
diff --git a/test/input_err_type/inf3.l b/test/input_err_type/inf3.l
new file mode 100644
index 0000000000000000000000000000000000000000..a57d7f48f95347c873492c906d1c400bd73ecc47
--- /dev/null
+++ b/test/input_err_type/inf3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai < faux);
+}
diff --git a/test/input_err_type/inf3.nasm b/test/input_err_type/inf3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cd004aa7a69c577b68f58ca733bc81b864b001d1
--- /dev/null
+++ b/test/input_err_type/inf3.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	1	;JumpIfLess 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/input_err_type/inf4.l b/test/input_err_type/inf4.l
new file mode 100644
index 0000000000000000000000000000000000000000..f0301e20bd9b8c4c283ee4a08b72e5fa8cee2a1c
--- /dev/null
+++ b/test/input_err_type/inf4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((1 < 1) + 1);
+}
diff --git a/test/input_err_type/mult1.l b/test/input_err_type/mult1.l
new file mode 100644
index 0000000000000000000000000000000000000000..8f4d37872c81b7d4790d19b15941cc7dda816738
--- /dev/null
+++ b/test/input_err_type/mult1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 * vrai);
+}
diff --git a/test/input_err_type/mult2.l b/test/input_err_type/mult2.l
new file mode 100644
index 0000000000000000000000000000000000000000..48f4598f03ec737de7b772c2dbbe421535aebc78
--- /dev/null
+++ b/test/input_err_type/mult2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai * 1);
+}
diff --git a/test/input_err_type/mult3.l b/test/input_err_type/mult3.l
new file mode 100644
index 0000000000000000000000000000000000000000..b836a332c9fbcc09aa43b17cf015345840e6e4f6
--- /dev/null
+++ b/test/input_err_type/mult3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai * faux);
+}
diff --git a/test/input_err_type/mult4.l b/test/input_err_type/mult4.l
new file mode 100644
index 0000000000000000000000000000000000000000..07a49bb4609b754c4c42b455cf3decb3208f3a59
--- /dev/null
+++ b/test/input_err_type/mult4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(!(1 * 1));
+}
diff --git a/test/input_err_type/not1.l b/test/input_err_type/not1.l
new file mode 100644
index 0000000000000000000000000000000000000000..12d8b4265d7d2cc24d9ccd81c72945be3713ddf5
--- /dev/null
+++ b/test/input_err_type/not1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(! 1);
+}
diff --git a/test/input_err_type/or1.l b/test/input_err_type/or1.l
new file mode 100644
index 0000000000000000000000000000000000000000..4c9d12991cfd796ffb9446af0fe045753e2f9327
--- /dev/null
+++ b/test/input_err_type/or1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai | 1);
+}
diff --git a/test/input_err_type/or2.l b/test/input_err_type/or2.l
new file mode 100644
index 0000000000000000000000000000000000000000..f4324ff7ab7477d94593a438630389e3d7260be8
--- /dev/null
+++ b/test/input_err_type/or2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 | faux);
+}
diff --git a/test/input_err_type/or3.l b/test/input_err_type/or3.l
new file mode 100644
index 0000000000000000000000000000000000000000..7bfcff9abcb2c11822c8fd790f145051b18647e7
--- /dev/null
+++ b/test/input_err_type/or3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((vrai | vrai) + 1);
+}
diff --git a/test/input_err_type/or4.l b/test/input_err_type/or4.l
new file mode 100644
index 0000000000000000000000000000000000000000..7bfcff9abcb2c11822c8fd790f145051b18647e7
--- /dev/null
+++ b/test/input_err_type/or4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire((vrai | vrai) + 1);
+}
diff --git a/test/input_err_type/retour1.l b/test/input_err_type/retour1.l
new file mode 100644
index 0000000000000000000000000000000000000000..dd2a19bcadab893fcd3968685d1f8bdc8ddd122c
--- /dev/null
+++ b/test/input_err_type/retour1.l
@@ -0,0 +1,9 @@
+bool f(entier a)
+{
+retour(a);
+}
+
+main()
+{
+f(3712);
+}
diff --git a/test/input_err_type/retour2.l b/test/input_err_type/retour2.l
new file mode 100644
index 0000000000000000000000000000000000000000..beedbe70a9d1a68aabdd785a494cc704a7d1b54e
--- /dev/null
+++ b/test/input_err_type/retour2.l
@@ -0,0 +1,9 @@
+entier f(bool a)
+{
+retour(a);
+}
+
+main()
+{
+f(vrai);
+}
diff --git a/test/input_err_type/retour3.l b/test/input_err_type/retour3.l
new file mode 100644
index 0000000000000000000000000000000000000000..76ced6479218a5eeff6298babb99ac8191fb5d91
--- /dev/null
+++ b/test/input_err_type/retour3.l
@@ -0,0 +1,9 @@
+f(entier a)
+{
+retour(a);
+}
+
+main()
+{
+f(3712);
+}
diff --git a/test/input_err_type/si1.l b/test/input_err_type/si1.l
new file mode 100644
index 0000000000000000000000000000000000000000..cb241484c9820d6b7c1a2c914f245685612093d9
--- /dev/null
+++ b/test/input_err_type/si1.l
@@ -0,0 +1,5 @@
+main()
+{
+si (1) alors {
+}
+}
diff --git a/test/input_err_type/sub1.l b/test/input_err_type/sub1.l
new file mode 100644
index 0000000000000000000000000000000000000000..8b8dd5522e075da4a1a00cbe88b6f0860cacdf7a
--- /dev/null
+++ b/test/input_err_type/sub1.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(1 - vrai);
+}
diff --git a/test/input_err_type/sub2.l b/test/input_err_type/sub2.l
new file mode 100644
index 0000000000000000000000000000000000000000..252c03f0ca29a350683fcdaa1b689a4ff9f58d34
--- /dev/null
+++ b/test/input_err_type/sub2.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai - 1);
+}
diff --git a/test/input_err_type/sub3.l b/test/input_err_type/sub3.l
new file mode 100644
index 0000000000000000000000000000000000000000..c36f785a07e66a94881b7476b0e2f9db36390ec6
--- /dev/null
+++ b/test/input_err_type/sub3.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(vrai - vrai);
+}
diff --git a/test/input_err_type/sub4.l b/test/input_err_type/sub4.l
new file mode 100644
index 0000000000000000000000000000000000000000..b6b7bfb9b8b8e83ce858937eb7633a9b613270e9
--- /dev/null
+++ b/test/input_err_type/sub4.l
@@ -0,0 +1,4 @@
+main()
+{
+ecrire(!( 1 - 1));
+}
diff --git a/test/input_err_type/tantque1.l b/test/input_err_type/tantque1.l
new file mode 100644
index 0000000000000000000000000000000000000000..6344c62ae0341316d4240bb848f11dfc77c27bdb
--- /dev/null
+++ b/test/input_err_type/tantque1.l
@@ -0,0 +1,5 @@
+main()
+{
+tantque (1) faire {
+}
+}
diff --git a/test/io.asm b/test/io.asm
new file mode 100644
index 0000000000000000000000000000000000000000..cee4da2ae3a4746873a75a15688938b608c91b87
--- /dev/null
+++ b/test/io.asm
@@ -0,0 +1,205 @@
+	global iprintLF
+;------------------------------------------
+; void readline
+; Read a line from stdin, store string after [$eax]
+; WARNING: does not check for buffer overflow - insecure!
+readline:    
+    push    edx        ; preserve edx on stack to be restored after function
+    push    ecx        ; preserve ecx on stack to be restored after function
+    push    ebx        ; preserve ebx on stack to be restored after function
+    push    eax        ; preserve eax on stack to be restored after function
+    mov ecx, eax       ; address where store result
+continue_reading:
+    mov	eax, 3         ; syscall is read = 3
+    mov	ebx, 0         ; fd is stdin = 0    
+    mov	edx, 1         ; nb. of bytes to read
+    int 80h            ; call interruption
+    cmp eax, 0         ; if no byte read, then we reached EOF, stop
+    je end_reading    
+    cmp BYTE [ecx], 10 ; Found '\n', stop reading string
+    je end_reading
+    cmp BYTE [ecx], 13 ; Found '\r', stop reading string
+    je end_reading
+    inc ecx            ; None of above, increment pointer and read next byte
+    jmp continue_reading
+end_reading:
+    mov BYTE [ecx], 0  ; Add zero to yield null-terminated string
+    pop     eax        ; restore eax from value pushed onto stack at start
+    pop     ebx        ; restore eax from value pushed onto stack at start
+    pop     ecx        ; restore eax from value pushed onto stack at start
+    pop     edx        ; restore eax from value pushed onto stack at start
+    ret
+
+;------------------------------------------
+; void iprint(Integer number)
+; Integer printing function (itoa)
+iprint:
+    push    eax             ; preserve eax on the stack to be restored after function runs
+    push    ecx             ; preserve ecx on the stack to be restored after function runs
+    push    edx             ; preserve edx on the stack to be restored after function runs
+    push    esi             ; preserve esi on the stack to be restored after function runs
+    
+    cmp	    eax, 0
+    jge      positive
+    push    eax             ; preserve eax value
+    mov     ebx, '-'
+    push    ebx
+    mov     eax, esp    
+    call sprint
+    pop     eax             ; remove '-' sign
+    pop     eax             ; retrieve eax value
+    neg     eax
+positive:
+    mov     ecx, 0          ; counter of how many bytes we need to print in the end 
+divideLoop:
+    inc     ecx             ; count each byte to print - number of characters
+    mov     edx, 0          ; empty edx
+    mov     esi, 10         ; mov 10 into esi
+    idiv    esi             ; divide eax by esi
+    add     edx, 48         ; convert edx to it's ascii representation - edx holds the remainder after a divide instruction
+    push    edx             ; push edx (string representation of an intger) onto the stack
+    cmp     eax, 0          ; can the integer be divided anymore?
+    jnz     divideLoop      ; jump if not zero to the label divideLoop
+ 
+printLoop:
+    dec     ecx             ; count down each byte that we put on the stack
+    mov     eax, esp        ; mov the stack pointer into eax for printing
+    call    sprint          ; call our string print function
+    pop     eax             ; remove last character from the stack to move esp forward
+    cmp     ecx, 0          ; have we printed all bytes we pushed onto the stack?
+    jnz     printLoop       ; jump is not zero to the label printLoop
+ 
+    pop     esi             ; restore esi from the value we pushed onto the stack at the start
+    pop     edx             ; restore edx from the value we pushed onto the stack at the start
+    pop     ecx             ; restore ecx from the value we pushed onto the stack at the start
+    pop     eax             ; restore eax from the value we pushed onto the stack at the start
+    ret
+ 
+ 
+;------------------------------------------
+; void iprintLF(Integer number)
+; Integer printing function with linefeed (itoa)
+iprintLF:
+    call    iprint          ; call our integer printing function
+ 
+    push    eax             ; push eax onto the stack to preserve it while we use the eax register in this function
+    mov     eax, 0Ah        ; move 0Ah into eax - 0Ah is the ascii character for a linefeed
+    push    eax             ; push the linefeed onto the stack so we can get the address
+    mov     eax, esp        ; move the address of the current stack pointer into eax for sprint
+    call    sprint          ; call our sprint function
+    pop     eax             ; remove our linefeed character from the stack
+    pop     eax             ; restore the original value of eax before our function was called
+    ret
+ 
+ 
+;------------------------------------------
+; int slen(String message)
+; String length calculation function
+slen:
+    push    ebx
+    mov     ebx, eax
+ 
+nextchar:
+    cmp     byte [eax], 0
+    jz      finished
+    inc     eax
+    jmp     nextchar
+ 
+finished:
+    sub     eax, ebx
+    pop     ebx
+    ret
+ 
+ 
+;------------------------------------------
+; void sprint(String message)
+; String printing function
+sprint:
+    push    edx
+    push    ecx
+    push    ebx
+    push    eax
+    call    slen
+ 
+    mov     edx, eax
+    pop     eax
+ 
+    mov     ecx, eax
+    mov     ebx, 1
+    mov     eax, 4
+    int     80h
+ 
+    pop     ebx
+    pop     ecx
+    pop     edx
+    ret
+ 
+ 
+;------------------------------------------
+; void sprintLF(String message)
+; String printing with line feed function
+sprintLF:
+    call    sprint
+ 
+    push    eax
+    mov     eax, 0AH
+    push    eax
+    mov     eax, esp
+    call    sprint
+    pop     eax
+    pop     eax
+    ret
+ 
+ 
+;------------------------------------------
+; void exit()
+; Exit program and restore resources
+quit:
+    mov     ebx, 0
+    mov     eax, 1
+    int     80h
+    ret
+
+;------------------------------------------
+; int atoi(Integer number)
+; Ascii to integer function (atoi)
+atoi:
+    push    ebx             ; preserve ebx on the stack to be restored after function runs
+    push    ecx             ; preserve ecx on the stack to be restored after function runs
+    push    edx             ; preserve edx on the stack to be restored after function runs
+    push    esi             ; preserve esi on the stack to be restored after function runs
+    xor     ebx, ebx        ; initialize forming answer
+    xor     ecx, ecx        ; initialize sign flag
+    mov     esi, eax
+atoi1: 
+    lodsb                   ; scan off whitespace
+    cmp     al, ' '         ; ignore leading blanks
+    je atoi1
+    cmp al, '+'             ; if + sign proceed
+    je atoi2
+    cmp al, '-'             ; is it - sign?
+    jne atoi3               ; no, test if numeric
+    dec ecx                 ; was - sign, set flag for negative result
+atoi2: 
+    lodsb                   ; get next character
+atoi3: 
+    cmp al,'0'        ; is character valid?
+    jb atoi4          ; jump if not '0' to '9'
+    cmp al,'9'
+    ja atoi4          ; jump if not '0' to '9'
+    and eax, 000fh     ; isolate lower four bits
+    xchg ebx, eax      ; multiply answer x 10
+    mov edx, 10
+    mul edx
+    add ebx, eax      ; add this digit
+    jmp atoi2         ; convert next digit
+atoi4: 
+    mov eax,ebx ; result into AX
+    jcxz atoi5 ; jump if sign flag clear
+    neg eax ; make result negative
+atoi5:
+    pop     esi             ; restore esi from the value we pushed onto the stack at the start
+    pop     edx             ; restore edx from the value we pushed onto the stack at the start
+    pop     ecx             ; restore ecx from the value we pushed onto the stack at the start
+    pop     ebx             ; restore ebx from the value we pushed onto the stack at the start
+    ret
diff --git a/test/nasm-ref/add1.nasm b/test/nasm-ref/add1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..bc09d48fc391ac1a47f33912e5b1fdca89447fd0
--- /dev/null
+++ b/test/nasm-ref/add1.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	3
+	add	eax,	10
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/add2.nasm b/test/nasm-ref/add2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..4410bcaf7e670b4fd228776e69275b62f4fabf20
--- /dev/null
+++ b/test/nasm-ref/add2.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2
+	add	eax,	4
+	mov	eax,	eax
+	add	eax,	8
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/affect1.nasm b/test/nasm-ref/affect1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..727926384620af32e1c1c412bcaaf20473e7a171
--- /dev/null
+++ b/test/nasm-ref/affect1.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+a :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [a],	1	;Affect
+	mov	eax,	dword [a]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/affect2.nasm b/test/nasm-ref/affect2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..13e0f37886036af558bc95f1d33ea5637553aaa6
--- /dev/null
+++ b/test/nasm-ref/affect2.nasm
@@ -0,0 +1,31 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	1	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/affect3.nasm b/test/nasm-ref/affect3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..0a52b93b4fc356494011718d51bb8eec982dc4b8
--- /dev/null
+++ b/test/nasm-ref/affect3.nasm
@@ -0,0 +1,50 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [ebp+12],	1	;Affect
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	push	3	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/and1.nasm b/test/nasm-ref/and1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a4246bc7784f17ded7c1f9f015fe35280f59b242
--- /dev/null
+++ b/test/nasm-ref/and1.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/and2.nasm b/test/nasm-ref/and2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c1132c69b97f30c4e8b928a1d6fd5c73a4b2a40d
--- /dev/null
+++ b/test/nasm-ref/and2.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/and3.nasm b/test/nasm-ref/and3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..47d936c85fc18a3f73806dd02341a71114996fd3
--- /dev/null
+++ b/test/nasm-ref/and3.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/and4.nasm b/test/nasm-ref/and4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ae6df09fc7f24b26251ff3684237a7b963b9b609
--- /dev/null
+++ b/test/nasm-ref/and4.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/and5.nasm b/test/nasm-ref/and5.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fa2e52fb7fa79ebf2aad22f3b84f4e4a3f2bfa19
--- /dev/null
+++ b/test/nasm-ref/and5.nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	eax,	0	;Affect
+l2 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel-param1.nasm b/test/nasm-ref/appel-param1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..54428e36a95e0d6708a06f4e8fb91652116ba96a
--- /dev/null
+++ b/test/nasm-ref/appel-param1.nasm
@@ -0,0 +1,49 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel-param2.nasm b/test/nasm-ref/appel-param2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..0ebec5e449f36bb52aa6d0385bb71ef1b1a71461
--- /dev/null
+++ b/test/nasm-ref/appel-param2.nasm
@@ -0,0 +1,52 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	push	456	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	8	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel-param3.nasm b/test/nasm-ref/appel-param3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..efa08558ce502d7f95b24c8ff197b1505a9d3ce4
--- /dev/null
+++ b/test/nasm-ref/appel-param3.nasm
@@ -0,0 +1,61 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+28]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+24]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+20]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	push	2	;Param
+	push	3	;Param
+	push	4	;Param
+	push	5	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	20	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel-retour1.nasm b/test/nasm-ref/appel-retour1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..45a6fd9d41fb43dbc5ee3ca8430198c6dc565cc4
--- /dev/null
+++ b/test/nasm-ref/appel-retour1.nasm
@@ -0,0 +1,58 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+12]	;ecriture de la valeur de retour
+	mov	dword [ebp+8],	eax	;on passe par un registre temporaire
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	3712	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel1.nasm b/test/nasm-ref/appel1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..67597761cad71746b4443ed76f0f5c142b1f6ef2
--- /dev/null
+++ b/test/nasm-ref/appel1.nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel2.nasm b/test/nasm-ref/appel2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..7cc2d8f7ccf7b60245a76f8c40ec95db89c67d96
--- /dev/null
+++ b/test/nasm-ref/appel2.nasm
@@ -0,0 +1,66 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+g :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	g
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/appel3.nasm b/test/nasm-ref/appel3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2b9a9dfa8c79a867801156d3100560c73feaa5e3
--- /dev/null
+++ b/test/nasm-ref/appel3.nasm
@@ -0,0 +1,66 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+g :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	g
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/div1.nasm b/test/nasm-ref/div1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ef462e72dde0a802a77735c5da97713811226fcd
--- /dev/null
+++ b/test/nasm-ref/div1.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	4	;affectation des bits de poids faible du dividende
+	mov	ebx,	2
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/div2.nasm b/test/nasm-ref/div2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..e861d6ef4a3a630827143a20a78ee1de334aff56
--- /dev/null
+++ b/test/nasm-ref/div2.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	0	;affectation des bits de poids faible du dividende
+	mov	ebx,	712
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/div3.nasm b/test/nasm-ref/div3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ffabe24f2bb040d5e7124496d8128358ac4e2ba4
--- /dev/null
+++ b/test/nasm-ref/div3.nasm
@@ -0,0 +1,42 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	4	;affectation des bits de poids faible du dividende
+	mov	ebx,	2
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	ebx,	eax
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	ebx	;affectation des bits de poids faible du dividende
+	mov	ebx,	2
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/div4.nasm b/test/nasm-ref/div4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f5097bb447d94b60666ff95a5df862fe292ca1eb
--- /dev/null
+++ b/test/nasm-ref/div4.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	2	;affectation des bits de poids faible du dividende
+	mov	ebx,	3
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/ecrire1.nasm b/test/nasm-ref/ecrire1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..b54f3ee63d0e79cb2afe62fa9a1e13a241383cc3
--- /dev/null
+++ b/test/nasm-ref/ecrire1.nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	3456	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/ecrire2.nasm b/test/nasm-ref/ecrire2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f1e10efec0cbbf021c4faeff5300f3baf120ddbd
--- /dev/null
+++ b/test/nasm-ref/ecrire2.nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/egal1.nasm b/test/nasm-ref/egal1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2f92dc2e56260860e4d6ff6ab4c8d7bcb238d5ba
--- /dev/null
+++ b/test/nasm-ref/egal1.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	123	;JumpIfEqual 1
+	cmp	eax,	123	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/egal2.nasm b/test/nasm-ref/egal2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..e18e7e7a25888dd4ff997c8949f599ddf428ccf0
--- /dev/null
+++ b/test/nasm-ref/egal2.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	412	;JumpIfEqual 1
+	cmp	eax,	34	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/egal3.nasm b/test/nasm-ref/egal3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ad070f93ff52c508f3c513825ecc06f69df54db8
--- /dev/null
+++ b/test/nasm-ref/egal3.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	2	;JumpIfEqual 1
+	cmp	eax,	2	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l1 :	mov	eax,	1	;Affect
+	cmp	ebx,	1	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/fibo.nasm b/test/nasm-ref/fibo.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ec408a375dfe24c1246df3e9a453499df4595844
--- /dev/null
+++ b/test/nasm-ref/fibo.nasm
@@ -0,0 +1,88 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+fibo :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Affect
+	cmp	dword [ebp+12],	2	;JumpIfLess 1
+	jl	l2	;JumpIfLess 2
+	mov	eax,	0	;Affect
+l2 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	jmp	l1	;Jump
+l0 :	mov	eax,	dword [ebp+12]
+	sub	eax,	1
+	push	eax	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	ecx	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	dword [ebp+12]
+	sub	eax,	2
+	push	eax	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	ebx	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	ecx
+	add	eax,	ebx
+	mov	dword [ebp+8],	eax	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	9	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/inf1.nasm b/test/nasm-ref/inf1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..bd13a5f82949fd1fae7cbdfb39adf8c218d5d159
--- /dev/null
+++ b/test/nasm-ref/inf1.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	3	;JumpIfLess 1
+	cmp	eax,	3	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/inf2.nasm b/test/nasm-ref/inf2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..affb58cf92cdc64faabc4b376374c695820a476d
--- /dev/null
+++ b/test/nasm-ref/inf2.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	4	;JumpIfLess 1
+	cmp	eax,	1	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/inf3.nasm b/test/nasm-ref/inf3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..5885172d49b57b6660a6ec3c490a6b5cff4e8cd0
--- /dev/null
+++ b/test/nasm-ref/inf3.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	312	;JumpIfLess 1
+	cmp	eax,	475	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/inf4.nasm b/test/nasm-ref/inf4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..013435ea8b6e1cfac6c51bcc687ffd8b954553a4
--- /dev/null
+++ b/test/nasm-ref/inf4.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	3	;JumpIfLess 1
+	cmp	eax,	2	;on passe par un registre temporaire
+	jl	l1	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l1 :	mov	eax,	1	;Affect
+	cmp	ebx,	1	;JumpIfLess 1
+	jl	l0	;JumpIfLess 2
+	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/nasm-ref/mult1.nasm b/test/nasm-ref/mult1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f76c44104b94899e0c418b997f73f88990ac6445
--- /dev/null
+++ b/test/nasm-ref/mult1.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2
+	imul	eax,	3
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/mult2.nasm b/test/nasm-ref/mult2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..6e1901e13d18d83e23df160556fe1d16939ab775
--- /dev/null
+++ b/test/nasm-ref/mult2.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0
+	imul	eax,	321
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/mult3.nasm b/test/nasm-ref/mult3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..63f4199dc9df139a894619b8ebd0d19191be46aa
--- /dev/null
+++ b/test/nasm-ref/mult3.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	3
+	imul	eax,	3
+	mov	eax,	eax
+	imul	eax,	2
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/not1.nasm b/test/nasm-ref/not1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fa6921f39b1fcccc8718d457632f539c03b0f914
--- /dev/null
+++ b/test/nasm-ref/not1.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/not2.nasm b/test/nasm-ref/not2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..7f55870901ad5f11302c4ef7311e33bbfcca9b0a
--- /dev/null
+++ b/test/nasm-ref/not2.nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/not3.nasm b/test/nasm-ref/not3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a2c8f2e76de74c40656a21c5490acbb237d31e95
--- /dev/null
+++ b/test/nasm-ref/not3.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l1 :	mov	eax,	1	;Affect
+	cmp	ebx,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/or1.nasm b/test/nasm-ref/or1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..7573ac5834c9877b7a3c57a3f6ba9799e00f7ebf
--- /dev/null
+++ b/test/nasm-ref/or1.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/or2.nasm b/test/nasm-ref/or2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..49b925dc5183ba3489419a53e0555d75a79875cb
--- /dev/null
+++ b/test/nasm-ref/or2.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/or3.nasm b/test/nasm-ref/or3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..03655bc1f89326096ae5ed01ad02d96c3bb8f0fb
--- /dev/null
+++ b/test/nasm-ref/or3.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/or4.nasm b/test/nasm-ref/or4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..aab700053973ffecf9a506a1434677cf1f05f810
--- /dev/null
+++ b/test/nasm-ref/or4.nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/or5.nasm b/test/nasm-ref/or5.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f5d577dc6fe141ecb82e2e76d77d3cc09d1ee479
--- /dev/null
+++ b/test/nasm-ref/or5.nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l3	;jumpIfNotEqual 2
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l3	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l2	;Jump
+l3 :	mov	eax,	1	;Affect
+l2 :	cmp	eax,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/parenth1.nasm b/test/nasm-ref/parenth1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..62131a5884a1b1293693324d2278bb1000744abb
--- /dev/null
+++ b/test/nasm-ref/parenth1.nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/parenth2.nasm b/test/nasm-ref/parenth2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a0a06fcdf1c8caf1975a4050d389b59e45d4fd2f
--- /dev/null
+++ b/test/nasm-ref/parenth2.nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio23-1.nasm b/test/nasm-ref/prio23-1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fe42a0a4facc3f2f4a3aa78a82f50c8f2d769a91
--- /dev/null
+++ b/test/nasm-ref/prio23-1.nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;
+	imul	eax,	10	;
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/nasm-ref/prio23-2.nasm b/test/nasm-ref/prio23-2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..3534b14cb4662d98e22441d2cf17636e70c34bf1
--- /dev/null
+++ b/test/nasm-ref/prio23-2.nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	10	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	3	;
+	imul	eax,	ebx	;
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/nasm-ref/prio23-3.nasm b/test/nasm-ref/prio23-3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1eaf5d10e872651eeac4e327b04dd33f44b33343
--- /dev/null
+++ b/test/nasm-ref/prio23-3.nasm
@@ -0,0 +1,41 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ecx,	1	;Affect
+	mov	ebx,	0	;JumpIfEqual 1
+	cmp	ebx,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ecx,	0	;Affect
+l0 :	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	ecx	;affectation des bits de poids faible du dividende
+	mov	ebx,	1	;
+	idiv	ebx	;
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax	;
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/nasm-ref/prio23-4.nasm b/test/nasm-ref/prio23-4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..e4ffdc78d55989222056554d2309f72632f41054
--- /dev/null
+++ b/test/nasm-ref/prio23-4.nasm
@@ -0,0 +1,45 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ecx,	1	;Affect
+	mov	ebx,	1	;JumpIfEqual 1
+	cmp	ebx,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ecx,	0	;Affect
+l0 :	mov	ebx,	1	;Affect
+	mov	edx,	0	;JumpIfEqual 1
+	cmp	edx,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l1 :	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	ecx	;affectation des bits de poids faible du dividende
+	idiv	ebx	;
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax	;
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/nasm-ref/prio34-1.nasm b/test/nasm-ref/prio34-1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cd6c5eea1bb371fc73fca215fffbc76cd7957bb6
--- /dev/null
+++ b/test/nasm-ref/prio34-1.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	3
+	imul	ebx,	4
+	mov	eax,	2
+	add	eax,	ebx
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio34-2.nasm b/test/nasm-ref/prio34-2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..702132656d75a76268080014ad572d805d6d344c
--- /dev/null
+++ b/test/nasm-ref/prio34-2.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2
+	imul	eax,	3
+	mov	eax,	eax
+	sub	eax,	4
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio34-3.nasm b/test/nasm-ref/prio34-3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1f40cf8885b925c20ea2e78aad5167d1a4d2fe50
--- /dev/null
+++ b/test/nasm-ref/prio34-3.nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	6	;affectation des bits de poids faible du dividende
+	mov	ebx,	3
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	eax,	eax
+	mov	eax,	eax
+	sub	eax,	72
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio34-4.nasm b/test/nasm-ref/prio34-4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..3de8b057f5a9916b165ee207975eda202cbb54d2
--- /dev/null
+++ b/test/nasm-ref/prio34-4.nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	20	;affectation des bits de poids faible du dividende
+	mov	ebx,	10
+	idiv	ebx
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	ebx,	eax
+	mov	eax,	6
+	add	eax,	ebx
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio45-1.nasm b/test/nasm-ref/prio45-1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..16084c61994289d9b5362b3383d9ad9bf1a8bc14
--- /dev/null
+++ b/test/nasm-ref/prio45-1.nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	0
+	add	ebx,	1
+	mov	ecx,	1	;Affect
+	mov	eax,	2	;JumpIfEqual 1
+	cmp	eax,	ebx	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	ecx,	0	;Affect
+l0 :	mov	eax,	ecx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio45-2.nasm b/test/nasm-ref/prio45-2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1df1bfcdbc9df9d11545b497a3e7159117327e81
--- /dev/null
+++ b/test/nasm-ref/prio45-2.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1
+	add	eax,	234
+	mov	ebx,	1	;Affect
+	cmp	eax,	1	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio45-3.nasm b/test/nasm-ref/prio45-3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..866931fb3d8f476c4121bac63c4dcf94902c5311
--- /dev/null
+++ b/test/nasm-ref/prio45-3.nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	11
+	add	ebx,	100
+	mov	ecx,	1	;Affect
+	mov	eax,	12	;JumpIfLess 1
+	cmp	eax,	ebx	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	ecx,	0	;Affect
+l0 :	mov	eax,	ecx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio45-4.nasm b/test/nasm-ref/prio45-4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..64778dc79a19f0dc04cc1f617abdf86c85d605f3
--- /dev/null
+++ b/test/nasm-ref/prio45-4.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	21
+	sub	eax,	21
+	mov	ebx,	1	;Affect
+	cmp	eax,	1	;JumpIfLess 1
+	jl	l0	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l0 :	mov	eax,	ebx	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio56-1.nasm b/test/nasm-ref/prio56-1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..dad85991cd6e823748a8a3902329ead4e9d4a8c2
--- /dev/null
+++ b/test/nasm-ref/prio56-1.nasm
@@ -0,0 +1,43 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	2	;on passe par un registre temporaire
+	je	l2	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l2 :	cmp	ebx,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio56-2.nasm b/test/nasm-ref/prio56-2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..5b41fc44c4d5b40dcd9affdb225e9994128aec3e
--- /dev/null
+++ b/test/nasm-ref/prio56-2.nasm
@@ -0,0 +1,43 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	ebx,	1	;Affect
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	1	;on passe par un registre temporaire
+	je	l2	;JumpIfEqual 2
+	mov	ebx,	0	;Affect
+l2 :	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	cmp	ebx,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio67-1.nasm b/test/nasm-ref/prio67-1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..dd5f56baf134dabc4bc97e3fe33bdc04186bd56f
--- /dev/null
+++ b/test/nasm-ref/prio67-1.nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	eax,	0	;Affect
+l2 :	cmp	eax,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/prio67-2.nasm b/test/nasm-ref/prio67-2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..94d07a6e3fba092d35e2b26c17a07cee77b7e9fc
--- /dev/null
+++ b/test/nasm-ref/prio67-2.nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	ebx,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	ebx,	0	;Affect
+l2 :	mov	eax,	1	;jumpIfNotEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	cmp	ebx,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	eax,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	1	;Affect
+l0 :	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/rec1.nasm b/test/nasm-ref/rec1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c0f7379bcc562b0a9b6b5d0129bf4a802eacdf3c
--- /dev/null
+++ b/test/nasm-ref/rec1.nasm
@@ -0,0 +1,81 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Affect
+	cmp	dword [ebp+12],	1	;JumpIfEqual 1
+	je	l2	;JumpIfEqual 2
+	mov	eax,	0	;Affect
+l2 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	jmp	l1	;Jump
+l0 :	mov	eax,	dword [ebp+12]
+	sub	eax,	1
+	push	eax	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	ebx	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	1
+	add	eax,	ebx
+	mov	dword [ebp+8],	eax	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	100	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/si1.nasm b/test/nasm-ref/si1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cc1e2372219877c535700bbdf8fbdedcd529efab
--- /dev/null
+++ b/test/nasm-ref/si1.nasm
@@ -0,0 +1,33 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/si2.nasm b/test/nasm-ref/si2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a79e6a022157c55621daa63c0d46bbd0d74e6611
--- /dev/null
+++ b/test/nasm-ref/si2.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/si3.nasm b/test/nasm-ref/si3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..4f10ce83ed61f3c02012539ba21eb69f65f3baa2
--- /dev/null
+++ b/test/nasm-ref/si3.nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/si4.nasm b/test/nasm-ref/si4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..4af0c4e6aeb54e4e7a17634e6acb249b76670315
--- /dev/null
+++ b/test/nasm-ref/si4.nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/si5.nasm b/test/nasm-ref/si5.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..06766335eec7827b2de84a64b694e940dcef3fca
--- /dev/null
+++ b/test/nasm-ref/si5.nasm
@@ -0,0 +1,40 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	1	;JumpIfEqual 1
+	cmp	eax,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+l3 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/sub1.nasm b/test/nasm-ref/sub1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..70cc077685dc58beb25f98a5eb3e11f757f20d18
--- /dev/null
+++ b/test/nasm-ref/sub1.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	10
+	sub	eax,	5
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/sub2.nasm b/test/nasm-ref/sub2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f8201ed61834abfc172407e856e33025e9121b9b
--- /dev/null
+++ b/test/nasm-ref/sub2.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	7
+	sub	eax,	20
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/sub3.nasm b/test/nasm-ref/sub3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f45bc0713e3fb59d884a7b9217c2b0dce4b30998
--- /dev/null
+++ b/test/nasm-ref/sub3.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2
+	sub	eax,	1
+	mov	eax,	eax
+	sub	eax,	1
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tab1.nasm b/test/nasm-ref/tab1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c5ab2add2074e38837bf5de00061ffdc9a3a7b3d
--- /dev/null
+++ b/test/nasm-ref/tab1.nasm
@@ -0,0 +1,50 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	12	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0
+	imul	eax,	4
+	mov	dword [tab+eax],	0	;Affect
+	mov	eax,	1
+	imul	eax,	4
+	mov	dword [tab+eax],	1	;Affect
+	mov	eax,	2
+	imul	eax,	4
+	mov	dword [tab+eax],	2	;Affect
+	mov	eax,	0
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	1
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	2
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tab2.nasm b/test/nasm-ref/tab2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..11220cb89069b4aaf6859ce73b3808bd45fbe150
--- /dev/null
+++ b/test/nasm-ref/tab2.nasm
@@ -0,0 +1,57 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	20	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	2	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	0
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	34	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	1
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	74	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	2
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	16	;Affect
+	mov	eax,	2
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	3
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	4
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tab3.nasm b/test/nasm-ref/tab3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a992cbd9ad038e9d499ea9adaf1ff223c97288a0
--- /dev/null
+++ b/test/nasm-ref/tab3.nasm
@@ -0,0 +1,60 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	20	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	2	;Affect
+	mov	dword [ebp-8],	0	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	dword [ebp-8]
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	34	;Affect
+	mov	dword [ebp-8],	1	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	dword [ebp-8]
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	74	;Affect
+	mov	dword [ebp-8],	2	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	dword [ebp-8]
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	16	;Affect
+	mov	eax,	2
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	3
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	4
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tab4.nasm b/test/nasm-ref/tab4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ebef473f49f9613d10a6afe4432d44bb0d6e27e1
--- /dev/null
+++ b/test/nasm-ref/tab4.nasm
@@ -0,0 +1,56 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	12	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0
+	imul	eax,	4
+	mov	dword [tab+eax],	1	;Affect
+	mov	eax,	0
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]
+	imul	eax,	4
+	mov	dword [tab+eax],	12	;Affect
+	mov	eax,	0
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]
+	add	eax,	1
+	mov	eax,	eax
+	imul	eax,	4
+	mov	dword [tab+eax],	13	;Affect
+	mov	eax,	0
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	1
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	2
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tantque1.nasm b/test/nasm-ref/tantque1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..7d86ffb50a36659402a88a7f97182d4db587883b
--- /dev/null
+++ b/test/nasm-ref/tantque1.nasm
@@ -0,0 +1,44 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+l0 :	mov	ebx,	1	;Affect
+	mov	eax,	0	;JumpIfLess 1
+	cmp	eax,	dword [ebp-4]	;on passe par un registre temporaire
+	jl	l2	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l2 :	cmp	ebx,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-4]
+	sub	eax,	1
+	mov	dword [ebp-4],	eax	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tantque2.nasm b/test/nasm-ref/tantque2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..760a37732b9f9519b9e5a3794650758aeeb5cf3e
--- /dev/null
+++ b/test/nasm-ref/tantque2.nasm
@@ -0,0 +1,54 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	0	;Affect
+l0 :	mov	eax,	1	;Affect
+	cmp	dword [ebp-4],	4	;JumpIfLess 1
+	jl	l2	;JumpIfLess 2
+	mov	eax,	0	;Affect
+l2 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	dword [ebp-8],	0	;Affect
+l3 :	mov	eax,	1	;Affect
+	cmp	dword [ebp-8],	4	;JumpIfLess 1
+	jl	l5	;JumpIfLess 2
+	mov	eax,	0	;Affect
+l5 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l4	;JumpIfEqual 2
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-8]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-8]
+	add	eax,	1
+	mov	dword [ebp-8],	eax	;Affect
+	jmp	l3	;Jump
+l4 :	mov	eax,	dword [ebp-4]
+	add	eax,	1
+	mov	dword [ebp-4],	eax	;Affect
+	jmp	l0	;Jump
+l1 :	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/tri.nasm b/test/nasm-ref/tri.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ed7a9fd07151cf5acf218d226eda0b9751a0e337
--- /dev/null
+++ b/test/nasm-ref/tri.nasm
@@ -0,0 +1,214 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	40	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+initialiser :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0
+	imul	eax,	4
+	mov	dword [tab+eax],	8	;Affect
+	mov	eax,	1
+	imul	eax,	4
+	mov	dword [tab+eax],	6	;Affect
+	mov	eax,	2
+	imul	eax,	4
+	mov	dword [tab+eax],	9	;Affect
+	mov	eax,	3
+	imul	eax,	4
+	mov	dword [tab+eax],	9	;Affect
+	mov	eax,	4
+	imul	eax,	4
+	mov	dword [tab+eax],	4	;Affect
+	mov	eax,	5
+	imul	eax,	4
+	mov	dword [tab+eax],	2	;Affect
+	mov	eax,	6
+	imul	eax,	4
+	mov	dword [tab+eax],	3	;Affect
+	mov	eax,	7
+	imul	eax,	4
+	mov	dword [tab+eax],	1	;Affect
+	mov	eax,	8
+	imul	eax,	4
+	mov	dword [tab+eax],	4	;Affect
+	mov	eax,	9
+	imul	eax,	4
+	mov	dword [tab+eax],	5	;Affect
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+afficher :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	0	;Affect
+l0 :	mov	ebx,	1	;Affect
+	mov	eax,	dword [ebp-4]	;JumpIfLess 1
+	cmp	eax,	dword [ebp+12]	;on passe par un registre temporaire
+	jl	l2	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l2 :	cmp	ebx,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	eax,	dword [ebp-4]
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-4]
+	add	eax,	1
+	mov	dword [ebp-4],	eax	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+echanger :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	eax,	dword [ebp+12]
+	imul	eax,	4
+	mov	eax,	dword [tab+eax]	;Affect
+	mov	dword [ebp-4],	eax	;on passe par un registre temporaire
+	mov	eax,	dword [ebp+16]
+	imul	eax,	4
+	mov	ebx,	dword [ebp+12]
+	imul	ebx,	4
+	mov	eax,	dword [tab+eax]	;Affect
+	mov	dword [tab+ebx],	eax	;on passe par un registre temporaire
+	mov	ebx,	dword [ebp+16]
+	imul	ebx,	4
+	mov	eax,	dword [ebp-4]	;Affect
+	mov	dword [tab+ebx],	eax	;on passe par un registre temporaire
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+trier :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	12	;allocation des variables locales
+	mov	eax,	dword [ebp+12]	;Affect
+	mov	dword [ebp-12],	eax	;on passe par un registre temporaire
+	mov	dword [ebp-4],	1	;Affect
+l3 :	mov	eax,	1	;Affect
+	cmp	dword [ebp-4],	1	;JumpIfEqual 1
+	je	l5	;JumpIfEqual 2
+	mov	eax,	0	;Affect
+l5 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l4	;JumpIfEqual 2
+	mov	dword [ebp-4],	0	;Affect
+	mov	dword [ebp-8],	0	;Affect
+l6 :	mov	eax,	dword [ebp-12]
+	sub	eax,	1
+	mov	ebx,	1	;Affect
+	cmp	dword [ebp-8],	eax	;JumpIfLess 1
+	jl	l8	;JumpIfLess 2
+	mov	ebx,	0	;Affect
+l8 :	cmp	ebx,	0	;JumpIfEqual 1
+	je	l7	;JumpIfEqual 2
+	mov	ebx,	dword [ebp-8]
+	add	ebx,	1
+	mov	eax,	1	;Affect
+	mov	ebx,	ebx
+	imul	ebx,	4
+	mov	ecx,	dword [ebp-8]
+	imul	ecx,	4
+	mov	ebx,	dword [tab+ebx]	;JumpIfLess 1
+	cmp	ebx,	dword [tab+ecx]	;on passe par un registre temporaire
+	jl	l11	;JumpIfLess 2
+	mov	eax,	0	;Affect
+l11 :	cmp	eax,	0	;JumpIfEqual 1
+	je	l10	;JumpIfEqual 2
+	push	dword [ebp-8]	;Param
+	mov	eax,	dword [ebp-8]
+	add	eax,	1
+	push	eax	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	echanger
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	8	;désallocation des arguments
+	mov	dword [ebp-4],	1	;Affect
+l10 :	mov	eax,	dword [ebp-8]
+	add	eax,	1
+	mov	dword [ebp-8],	eax	;Affect
+	jmp	l6	;Jump
+l7 :	mov	eax,	dword [ebp-12]
+	sub	eax,	1
+	mov	dword [ebp-12],	eax	;Affect
+	jmp	l3	;Jump
+l4 :	add	esp,	12	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	initialiser
+	pop	eax	;récupération de la valeur de retour
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	afficher
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	trier
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	afficher
+	pop	eax	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varglob1.nasm b/test/nasm-ref/varglob1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f2d6bb521d13b69045c307f12b9e81348baa3641
--- /dev/null
+++ b/test/nasm-ref/varglob1.nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+variable :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [variable],	6834	;Affect
+	mov	eax,	dword [variable]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varglob2.nasm b/test/nasm-ref/varglob2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..0d3aa1a3bca6108ca17fe9b50da63c1ace553650
--- /dev/null
+++ b/test/nasm-ref/varglob2.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+variable :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [variable],	10	;Affect
+	mov	eax,	dword [variable]
+	add	eax,	50
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varglob3.nasm b/test/nasm-ref/varglob3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..3e82be48c92841b4976cf0fffc764208e911726b
--- /dev/null
+++ b/test/nasm-ref/varglob3.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var2 :	resd	4	;variable globale
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	10	;Affect
+	mov	dword [var2],	34	;Affect
+	mov	eax,	dword [var1]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [var2]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varglob4.nasm b/test/nasm-ref/varglob4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..426256a88109e0f882b83372a0635a2588731d4e
--- /dev/null
+++ b/test/nasm-ref/varglob4.nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var2 :	resd	4	;variable globale
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	10	;Affect
+	mov	dword [var2],	34	;Affect
+	mov	eax,	dword [var1]
+	add	eax,	dword [var2]
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varloc1.nasm b/test/nasm-ref/varloc1.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f16e7b409d9e4b872dfccfb45e8e69fa21ba19a1
--- /dev/null
+++ b/test/nasm-ref/varloc1.nasm
@@ -0,0 +1,31 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	6834	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varloc2.nasm b/test/nasm-ref/varloc2.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..6fa1b7fd362a189759c978fd86059e00ed63559c
--- /dev/null
+++ b/test/nasm-ref/varloc2.nasm
@@ -0,0 +1,33 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	50
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varloc3.nasm b/test/nasm-ref/varloc3.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..821c6cd33f1f8a3cfb2863eb81590e67f9d6c2ba
--- /dev/null
+++ b/test/nasm-ref/varloc3.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	dword [ebp-8],	30	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-8]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varloc4.nasm b/test/nasm-ref/varloc4.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..931ea5887a9c95b25affb1d4ff2dec5a91fdff8b
--- /dev/null
+++ b/test/nasm-ref/varloc4.nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	dword [ebp-8],	30	;Affect
+	mov	eax,	dword [ebp-4]
+	add	eax,	dword [ebp-8]
+	mov	eax,	eax	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/nasm-ref/varloc5.nasm b/test/nasm-ref/varloc5.nasm
new file mode 100644
index 0000000000000000000000000000000000000000..58b8668461824e8d54f75b605d3a4543d37fc01b
--- /dev/null
+++ b/test/nasm-ref/varloc5.nasm
@@ -0,0 +1,52 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	eax	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	20	;Affect
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	eax	;récupération de la valeur de retour
+	mov	eax,	dword [var1]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/out-ref/add1.out b/test/out-ref/add1.out
new file mode 100644
index 0000000000000000000000000000000000000000..b1bd38b62a0800a4f6a80c34e21c5acffae52c7e
--- /dev/null
+++ b/test/out-ref/add1.out
@@ -0,0 +1 @@
+13
diff --git a/test/out-ref/add2.out b/test/out-ref/add2.out
new file mode 100644
index 0000000000000000000000000000000000000000..8351c19397f4fcd5238d10034fa7fa384f14d580
--- /dev/null
+++ b/test/out-ref/add2.out
@@ -0,0 +1 @@
+14
diff --git a/test/out-ref/affect1.out b/test/out-ref/affect1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/affect1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/affect2.out b/test/out-ref/affect2.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/affect2.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/affect3.out b/test/out-ref/affect3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/affect3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/and1.out b/test/out-ref/and1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/and1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/and2.out b/test/out-ref/and2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/and2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/and3.out b/test/out-ref/and3.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/and3.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/and4.out b/test/out-ref/and4.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/and4.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/and5.out b/test/out-ref/and5.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/and5.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/appel-param1.out b/test/out-ref/appel-param1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/appel-param1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/appel-param2.out b/test/out-ref/appel-param2.out
new file mode 100644
index 0000000000000000000000000000000000000000..fe3862e97aff6431de7f25a36a96f784da747858
--- /dev/null
+++ b/test/out-ref/appel-param2.out
@@ -0,0 +1,2 @@
+1
+456
diff --git a/test/out-ref/appel-param3.out b/test/out-ref/appel-param3.out
new file mode 100644
index 0000000000000000000000000000000000000000..8a1218a1024a212bb3db30becd860315f9f3ac52
--- /dev/null
+++ b/test/out-ref/appel-param3.out
@@ -0,0 +1,5 @@
+1
+2
+3
+4
+5
diff --git a/test/out-ref/appel-retour1.out b/test/out-ref/appel-retour1.out
new file mode 100644
index 0000000000000000000000000000000000000000..810283d091520435fc538cacd1218df2a2b8e706
--- /dev/null
+++ b/test/out-ref/appel-retour1.out
@@ -0,0 +1 @@
+3712
diff --git a/test/out-ref/appel1.out b/test/out-ref/appel1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/appel1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/appel2.out b/test/out-ref/appel2.out
new file mode 100644
index 0000000000000000000000000000000000000000..1191247b6d9a206f6ba3d8ac79e26d041dd86941
--- /dev/null
+++ b/test/out-ref/appel2.out
@@ -0,0 +1,2 @@
+1
+2
diff --git a/test/out-ref/appel3.out b/test/out-ref/appel3.out
new file mode 100644
index 0000000000000000000000000000000000000000..1191247b6d9a206f6ba3d8ac79e26d041dd86941
--- /dev/null
+++ b/test/out-ref/appel3.out
@@ -0,0 +1,2 @@
+1
+2
diff --git a/test/out-ref/div1.out b/test/out-ref/div1.out
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/test/out-ref/div1.out
@@ -0,0 +1 @@
+2
diff --git a/test/out-ref/div2.out b/test/out-ref/div2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/div2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/div3.out b/test/out-ref/div3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/div3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/div4.out b/test/out-ref/div4.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/div4.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/ecrire1.out b/test/out-ref/ecrire1.out
new file mode 100644
index 0000000000000000000000000000000000000000..169efa8bd26e4837bafefa6e14c2abee4541f6bc
--- /dev/null
+++ b/test/out-ref/ecrire1.out
@@ -0,0 +1 @@
+3456
diff --git a/test/out-ref/ecrire2.out b/test/out-ref/ecrire2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/ecrire2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/egal1.out b/test/out-ref/egal1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/egal1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/egal2.out b/test/out-ref/egal2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/egal2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/egal3.out b/test/out-ref/egal3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/egal3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/err5.out b/test/out-ref/err5.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/err5.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/fibo.out b/test/out-ref/fibo.out
new file mode 100644
index 0000000000000000000000000000000000000000..c3f407c0955bb5738e40a82664c79b63f04a9adb
--- /dev/null
+++ b/test/out-ref/fibo.out
@@ -0,0 +1 @@
+55
diff --git a/test/out-ref/inf1.out b/test/out-ref/inf1.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/inf1.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/inf2.out b/test/out-ref/inf2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/inf2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/inf3.out b/test/out-ref/inf3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/inf3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/inf4.out b/test/out-ref/inf4.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/inf4.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/mult1.out b/test/out-ref/mult1.out
new file mode 100644
index 0000000000000000000000000000000000000000..1e8b314962144c26d5e0e50fd29d2ca327864913
--- /dev/null
+++ b/test/out-ref/mult1.out
@@ -0,0 +1 @@
+6
diff --git a/test/out-ref/mult2.out b/test/out-ref/mult2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/mult2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/mult3.out b/test/out-ref/mult3.out
new file mode 100644
index 0000000000000000000000000000000000000000..3c032078a4a21c5c51d3c93d91717c1dabbb8cd0
--- /dev/null
+++ b/test/out-ref/mult3.out
@@ -0,0 +1 @@
+18
diff --git a/test/out-ref/not1.out b/test/out-ref/not1.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/not1.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/not2.out b/test/out-ref/not2.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/not2.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/not3.out b/test/out-ref/not3.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/not3.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/or1.out b/test/out-ref/or1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/or1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/or2.out b/test/out-ref/or2.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/or2.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/or3.out b/test/out-ref/or3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/or3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/or4.out b/test/out-ref/or4.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/or4.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/or5.out b/test/out-ref/or5.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/or5.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/parenth1.out b/test/out-ref/parenth1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/parenth1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/parenth2.out b/test/out-ref/parenth2.out
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/test/out-ref/parenth2.out
@@ -0,0 +1 @@
+2
diff --git a/test/out-ref/prio23-1.out b/test/out-ref/prio23-1.out
new file mode 100644
index 0000000000000000000000000000000000000000..f599e28b8ab0d8c9c57a486c89c4a5132dcbd3b2
--- /dev/null
+++ b/test/out-ref/prio23-1.out
@@ -0,0 +1 @@
+10
diff --git a/test/out-ref/prio23-2.out b/test/out-ref/prio23-2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/prio23-2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/prio23-3.out b/test/out-ref/prio23-3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio23-3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/prio23-4.out b/test/out-ref/prio23-4.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/prio23-4.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/prio34-1.out b/test/out-ref/prio34-1.out
new file mode 100644
index 0000000000000000000000000000000000000000..8351c19397f4fcd5238d10034fa7fa384f14d580
--- /dev/null
+++ b/test/out-ref/prio34-1.out
@@ -0,0 +1 @@
+14
diff --git a/test/out-ref/prio34-2.out b/test/out-ref/prio34-2.out
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/test/out-ref/prio34-2.out
@@ -0,0 +1 @@
+2
diff --git a/test/out-ref/prio34-3.out b/test/out-ref/prio34-3.out
new file mode 100644
index 0000000000000000000000000000000000000000..6446481c167171aff70c87e1568d957769e38bc3
--- /dev/null
+++ b/test/out-ref/prio34-3.out
@@ -0,0 +1 @@
+-70
diff --git a/test/out-ref/prio34-4.out b/test/out-ref/prio34-4.out
new file mode 100644
index 0000000000000000000000000000000000000000..45a4fb75db864000d01701c0f7a51864bd4daabf
--- /dev/null
+++ b/test/out-ref/prio34-4.out
@@ -0,0 +1 @@
+8
diff --git a/test/out-ref/prio45-1.out b/test/out-ref/prio45-1.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/prio45-1.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/prio45-2.out b/test/out-ref/prio45-2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/prio45-2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/prio45-3.out b/test/out-ref/prio45-3.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio45-3.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/prio45-4.out b/test/out-ref/prio45-4.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio45-4.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/prio56-1.out b/test/out-ref/prio56-1.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/prio56-1.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/prio56-2.out b/test/out-ref/prio56-2.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio56-2.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/prio67-1.out b/test/out-ref/prio67-1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio67-1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/prio67-2.out b/test/out-ref/prio67-2.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/prio67-2.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/rec1.out b/test/out-ref/rec1.out
new file mode 100644
index 0000000000000000000000000000000000000000..29d6383b52c1352e92a45875b5bb206f89139643
--- /dev/null
+++ b/test/out-ref/rec1.out
@@ -0,0 +1 @@
+100
diff --git a/test/out-ref/si1.out b/test/out-ref/si1.out
new file mode 100644
index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d
--- /dev/null
+++ b/test/out-ref/si1.out
@@ -0,0 +1 @@
+1
diff --git a/test/out-ref/si2.out b/test/out-ref/si2.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/si2.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/si3.out b/test/out-ref/si3.out
new file mode 100644
index 0000000000000000000000000000000000000000..6ed281c757a969ffe22f3dcfa5830c532479c726
--- /dev/null
+++ b/test/out-ref/si3.out
@@ -0,0 +1,2 @@
+1
+1
diff --git a/test/out-ref/si4.out b/test/out-ref/si4.out
new file mode 100644
index 0000000000000000000000000000000000000000..0d66ea1aee9527bfa39185ead1f9cdbd96bba88c
--- /dev/null
+++ b/test/out-ref/si4.out
@@ -0,0 +1,2 @@
+0
+1
diff --git a/test/out-ref/si5.out b/test/out-ref/si5.out
new file mode 100644
index 0000000000000000000000000000000000000000..e8183f05f5db68b3934e93f4bf6bed2bb664e0b5
--- /dev/null
+++ b/test/out-ref/si5.out
@@ -0,0 +1,3 @@
+1
+1
+1
diff --git a/test/out-ref/sub1.out b/test/out-ref/sub1.out
new file mode 100644
index 0000000000000000000000000000000000000000..7ed6ff82de6bcc2a78243fc9c54d3ef5ac14da69
--- /dev/null
+++ b/test/out-ref/sub1.out
@@ -0,0 +1 @@
+5
diff --git a/test/out-ref/sub2.out b/test/out-ref/sub2.out
new file mode 100644
index 0000000000000000000000000000000000000000..995f07c1771038b195c79e1bc5ab02d3afd24365
--- /dev/null
+++ b/test/out-ref/sub2.out
@@ -0,0 +1 @@
+-13
diff --git a/test/out-ref/sub3.out b/test/out-ref/sub3.out
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/test/out-ref/sub3.out
@@ -0,0 +1 @@
+0
diff --git a/test/out-ref/tab1.out b/test/out-ref/tab1.out
new file mode 100644
index 0000000000000000000000000000000000000000..4539bbf2d22d5c3b4227859ff854eda060a687fb
--- /dev/null
+++ b/test/out-ref/tab1.out
@@ -0,0 +1,3 @@
+0
+1
+2
diff --git a/test/out-ref/tab2.out b/test/out-ref/tab2.out
new file mode 100644
index 0000000000000000000000000000000000000000..ecfe662f10f360d0149e928b84dbf433e56ce3bd
--- /dev/null
+++ b/test/out-ref/tab2.out
@@ -0,0 +1,3 @@
+34
+74
+16
diff --git a/test/out-ref/tab3.out b/test/out-ref/tab3.out
new file mode 100644
index 0000000000000000000000000000000000000000..ecfe662f10f360d0149e928b84dbf433e56ce3bd
--- /dev/null
+++ b/test/out-ref/tab3.out
@@ -0,0 +1,3 @@
+34
+74
+16
diff --git a/test/out-ref/tab4.out b/test/out-ref/tab4.out
new file mode 100644
index 0000000000000000000000000000000000000000..fa56b0b3ea69abbe8ff34c4b602e7f66b06c6b1a
--- /dev/null
+++ b/test/out-ref/tab4.out
@@ -0,0 +1,3 @@
+1
+12
+13
diff --git a/test/out-ref/tantque1.out b/test/out-ref/tantque1.out
new file mode 100644
index 0000000000000000000000000000000000000000..30b148df5474850ce0add0d62d9e1aa76c84293f
--- /dev/null
+++ b/test/out-ref/tantque1.out
@@ -0,0 +1,11 @@
+10
+9
+8
+7
+6
+5
+4
+3
+2
+1
+0
diff --git a/test/out-ref/tantque2.out b/test/out-ref/tantque2.out
new file mode 100644
index 0000000000000000000000000000000000000000..4ee1d372736b4de691e829a3b53a0acccc95411c
--- /dev/null
+++ b/test/out-ref/tantque2.out
@@ -0,0 +1,32 @@
+0
+0
+0
+1
+0
+2
+0
+3
+1
+0
+1
+1
+1
+2
+1
+3
+2
+0
+2
+1
+2
+2
+2
+3
+3
+0
+3
+1
+3
+2
+3
+3
diff --git a/test/out-ref/tri.out b/test/out-ref/tri.out
new file mode 100644
index 0000000000000000000000000000000000000000..d32f608d46a00bc248c8d9d9570fcaacd4b33de7
--- /dev/null
+++ b/test/out-ref/tri.out
@@ -0,0 +1,22 @@
+8
+6
+9
+9
+4
+2
+3
+1
+4
+5
+0
+1
+2
+3
+4
+4
+5
+6
+8
+9
+9
+0
diff --git a/test/out-ref/varglob1.out b/test/out-ref/varglob1.out
new file mode 100644
index 0000000000000000000000000000000000000000..0f94b342b49eb656ef0db53ce65dfb6092f5678f
--- /dev/null
+++ b/test/out-ref/varglob1.out
@@ -0,0 +1 @@
+6834
diff --git a/test/out-ref/varglob2.out b/test/out-ref/varglob2.out
new file mode 100644
index 0000000000000000000000000000000000000000..abdfb053e41e2af75ba7e11f82b4ef0c312566a7
--- /dev/null
+++ b/test/out-ref/varglob2.out
@@ -0,0 +1 @@
+60
diff --git a/test/out-ref/varglob3.out b/test/out-ref/varglob3.out
new file mode 100644
index 0000000000000000000000000000000000000000..8ba133e658309023e62c05c237929c3078b8967a
--- /dev/null
+++ b/test/out-ref/varglob3.out
@@ -0,0 +1,2 @@
+10
+34
diff --git a/test/out-ref/varglob4.out b/test/out-ref/varglob4.out
new file mode 100644
index 0000000000000000000000000000000000000000..c739b42c4d2ce23786c5350641d0adbf5fa7d6b2
--- /dev/null
+++ b/test/out-ref/varglob4.out
@@ -0,0 +1 @@
+44
diff --git a/test/out-ref/varloc1.out b/test/out-ref/varloc1.out
new file mode 100644
index 0000000000000000000000000000000000000000..0f94b342b49eb656ef0db53ce65dfb6092f5678f
--- /dev/null
+++ b/test/out-ref/varloc1.out
@@ -0,0 +1 @@
+6834
diff --git a/test/out-ref/varloc2.out b/test/out-ref/varloc2.out
new file mode 100644
index 0000000000000000000000000000000000000000..abdfb053e41e2af75ba7e11f82b4ef0c312566a7
--- /dev/null
+++ b/test/out-ref/varloc2.out
@@ -0,0 +1 @@
+60
diff --git a/test/out-ref/varloc3.out b/test/out-ref/varloc3.out
new file mode 100644
index 0000000000000000000000000000000000000000..3d1851ccebea47571d78882cecb31cc6c89b85d2
--- /dev/null
+++ b/test/out-ref/varloc3.out
@@ -0,0 +1,2 @@
+10
+30
diff --git a/test/out-ref/varloc4.out b/test/out-ref/varloc4.out
new file mode 100644
index 0000000000000000000000000000000000000000..425151f3a411f5e088d7753e7c8d016303b1b9d1
--- /dev/null
+++ b/test/out-ref/varloc4.out
@@ -0,0 +1 @@
+40
diff --git a/test/out-ref/varloc5.out b/test/out-ref/varloc5.out
new file mode 100644
index 0000000000000000000000000000000000000000..3b86147b3542fae0e5e4cdb03bd17a50cf7e758f
--- /dev/null
+++ b/test/out-ref/varloc5.out
@@ -0,0 +1,2 @@
+10
+20
diff --git a/test/pre-nasm-ref/add1.pre-nasm b/test/pre-nasm-ref/add1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a85129f01a46f39ffc46fbec4b86c2d20a75a261
--- /dev/null
+++ b/test/pre-nasm-ref/add1.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	3
+	add	@1,	10
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/add2.pre-nasm b/test/pre-nasm-ref/add2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c32aa25720276d0f6670fd49f058f6ad0dc390b2
--- /dev/null
+++ b/test/pre-nasm-ref/add2.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	2
+	add	@1,	4
+	mov	@2,	@1
+	add	@2,	8
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/affect1.pre-nasm b/test/pre-nasm-ref/affect1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..58fe6a9c7656d16c7e212374b07f6446bb5458de
--- /dev/null
+++ b/test/pre-nasm-ref/affect1.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+a :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [a],	1	;Affect
+	mov	eax,	dword [a]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/affect2.pre-nasm b/test/pre-nasm-ref/affect2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c5e4bb771f15ed9880bf2eb9a4d3eac151665b54
--- /dev/null
+++ b/test/pre-nasm-ref/affect2.pre-nasm
@@ -0,0 +1,31 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	1	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/affect3.pre-nasm b/test/pre-nasm-ref/affect3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cad08c4c12780a20722d1110fec348ccb03db02b
--- /dev/null
+++ b/test/pre-nasm-ref/affect3.pre-nasm
@@ -0,0 +1,50 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [ebp+12],	1	;Affect
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	push	3	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/and1.pre-nasm b/test/pre-nasm-ref/and1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..13ff14a63e3ff3294d8e586405463c7506d587f8
--- /dev/null
+++ b/test/pre-nasm-ref/and1.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	1	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/and2.pre-nasm b/test/pre-nasm-ref/and2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cc749c501293dd723111bbf8f696c9b5ff80b397
--- /dev/null
+++ b/test/pre-nasm-ref/and2.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	1	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@9,	0	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/and3.pre-nasm b/test/pre-nasm-ref/and3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..96293418ed3365cd83127d61d8490e88a513339c
--- /dev/null
+++ b/test/pre-nasm-ref/and3.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	0	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/and4.pre-nasm b/test/pre-nasm-ref/and4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..99c1ee1bbb1427e04c5cd28def80cfe306daeeb5
--- /dev/null
+++ b/test/pre-nasm-ref/and4.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	0	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@9,	0	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/and5.pre-nasm b/test/pre-nasm-ref/and5.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cace673b5854a9f1bf5e078c297cd1ab8ffc60b4
--- /dev/null
+++ b/test/pre-nasm-ref/and5.pre-nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@10,	0	;JumpIfEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@2,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	@2,	0	;Affect
+l2 :	cmp	@2,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	@11,	1	;JumpIfEqual 1
+	cmp	@11,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel-param1.pre-nasm b/test/pre-nasm-ref/appel-param1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fd584ca3b762727a5d8c38cf4a7cce5b5e5ce5de
--- /dev/null
+++ b/test/pre-nasm-ref/appel-param1.pre-nasm
@@ -0,0 +1,49 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel-param2.pre-nasm b/test/pre-nasm-ref/appel-param2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1a57087c0f9b9f6173528a391620d50bba781922
--- /dev/null
+++ b/test/pre-nasm-ref/appel-param2.pre-nasm
@@ -0,0 +1,52 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	push	456	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	8	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel-param3.pre-nasm b/test/pre-nasm-ref/appel-param3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..78e7ab7a31e139612972392c36e87c2e3ed2ad94
--- /dev/null
+++ b/test/pre-nasm-ref/appel-param3.pre-nasm
@@ -0,0 +1,61 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	dword [ebp+28]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+24]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+20]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp+12]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	1	;Param
+	push	2	;Param
+	push	3	;Param
+	push	4	;Param
+	push	5	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	20	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel-retour1.pre-nasm b/test/pre-nasm-ref/appel-retour1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..08411802c832b988ee0d165f1dd6b528d8b31215
--- /dev/null
+++ b/test/pre-nasm-ref/appel-retour1.pre-nasm
@@ -0,0 +1,58 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	dword [ebp+12]	;ecriture de la valeur de retour
+	mov	dword [ebp+8],	@8	;on passe par un registre temporaire
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	3712	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel1.pre-nasm b/test/pre-nasm-ref/appel1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..ff0343548b797b307f8b9de344ea817f2746b97c
--- /dev/null
+++ b/test/pre-nasm-ref/appel1.pre-nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel2.pre-nasm b/test/pre-nasm-ref/appel2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..354f57911a6b0a70f5ea73401f3be3e54df86d39
--- /dev/null
+++ b/test/pre-nasm-ref/appel2.pre-nasm
@@ -0,0 +1,66 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+g :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	g
+	pop	@1	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@2	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/appel3.pre-nasm b/test/pre-nasm-ref/appel3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..6246b00713e3a10576bd1b0d66b2b3576497b30b
--- /dev/null
+++ b/test/pre-nasm-ref/appel3.pre-nasm
@@ -0,0 +1,66 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+g :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	g
+	pop	@2	;récupération de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/div1.pre-nasm b/test/pre-nasm-ref/div1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fdbadf0f339b8e7d2389c94c4c386b8bcae75b54
--- /dev/null
+++ b/test/pre-nasm-ref/div1.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	4	;affectation des bits de poids faible du dividende
+	mov	@10,	2
+	idiv	@10
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/div2.pre-nasm b/test/pre-nasm-ref/div2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..03e43c72a99ebb878e7ab26f547032fe242d892c
--- /dev/null
+++ b/test/pre-nasm-ref/div2.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	0	;affectation des bits de poids faible du dividende
+	mov	@10,	712
+	idiv	@10
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/div3.pre-nasm b/test/pre-nasm-ref/div3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..27cec5c12aca50fbe09922d90e117b91aee31786
--- /dev/null
+++ b/test/pre-nasm-ref/div3.pre-nasm
@@ -0,0 +1,42 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	4	;affectation des bits de poids faible du dividende
+	mov	@11,	2
+	idiv	@11
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	@1	;affectation des bits de poids faible du dividende
+	mov	@15,	2
+	idiv	@15
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@2,	eax
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/div4.pre-nasm b/test/pre-nasm-ref/div4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..af05666e3cadda5d0708be05ca608faa57e7bc8d
--- /dev/null
+++ b/test/pre-nasm-ref/div4.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	2	;affectation des bits de poids faible du dividende
+	mov	@10,	3
+	idiv	@10
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/ecrire1.pre-nasm b/test/pre-nasm-ref/ecrire1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..e49a65c2c56dde7f3c493b52ecaa50c8f0f4fdb7
--- /dev/null
+++ b/test/pre-nasm-ref/ecrire1.pre-nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	3456	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/ecrire2.pre-nasm b/test/pre-nasm-ref/ecrire2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cf9c03969b909c4d332871be32365b0194805485
--- /dev/null
+++ b/test/pre-nasm-ref/ecrire2.pre-nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/egal1.pre-nasm b/test/pre-nasm-ref/egal1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..427c6ce89c732fb3b2b497840c8b01e98da91f93
--- /dev/null
+++ b/test/pre-nasm-ref/egal1.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	123	;JumpIfEqual 1
+	cmp	@8,	123	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/egal2.pre-nasm b/test/pre-nasm-ref/egal2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..b85f93d7efd769ee3991c1a94dc1899ba1fa467e
--- /dev/null
+++ b/test/pre-nasm-ref/egal2.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	412	;JumpIfEqual 1
+	cmp	@8,	34	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/egal3.pre-nasm b/test/pre-nasm-ref/egal3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..e0e2b8979b0ebe85f68eb9fd5415d2c75d06729b
--- /dev/null
+++ b/test/pre-nasm-ref/egal3.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	1	;Affect
+	mov	@9,	2	;JumpIfEqual 1
+	cmp	@9,	2	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@2,	0	;Affect
+l1 :	mov	@1,	1	;Affect
+	cmp	@2,	1	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/fibo.pre-nasm b/test/pre-nasm-ref/fibo.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..bea531a62c6829c395621108469648e4d03f58e6
--- /dev/null
+++ b/test/pre-nasm-ref/fibo.pre-nasm
@@ -0,0 +1,88 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+fibo :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	cmp	dword [ebp+12],	2	;JumpIfLess 1
+	jl	l2	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l2 :	cmp	@1,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	jmp	l1	;Jump
+l0 :	mov	@3,	dword [ebp+12]
+	sub	@3,	1
+	push	@3	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	@2	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	@5,	dword [ebp+12]
+	sub	@5,	2
+	push	@5	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	@4	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	@6,	@2
+	add	@6,	@4
+	mov	dword [ebp+8],	@6	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	9	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	fibo
+	pop	@7	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	@7	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/inf1.pre-nasm b/test/pre-nasm-ref/inf1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a0f0f2d5929b5d38452b53dff981e35b1cc78dc5
--- /dev/null
+++ b/test/pre-nasm-ref/inf1.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	3	;JumpIfLess 1
+	cmp	@8,	3	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/inf2.pre-nasm b/test/pre-nasm-ref/inf2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..acd3a8aa9251fa288b037d29c6209f1224d98369
--- /dev/null
+++ b/test/pre-nasm-ref/inf2.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	4	;JumpIfLess 1
+	cmp	@8,	1	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/inf3.pre-nasm b/test/pre-nasm-ref/inf3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..eadc985c2c4e9c00f67c32d3c7d6a4ef77ff1884
--- /dev/null
+++ b/test/pre-nasm-ref/inf3.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	312	;JumpIfLess 1
+	cmp	@8,	475	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/inf4.pre-nasm b/test/pre-nasm-ref/inf4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..9c902817bf8ba6e5d6d8f8f6c2870709f7360c2a
--- /dev/null
+++ b/test/pre-nasm-ref/inf4.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	r0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	r2,	1	;Affect
+	mov	r9,	3	;JumpIfLess 1
+	cmp	r9,	2	;on passe par un registre temporaire
+	jl	l1	;JumpIfLess 2
+	mov	r2,	0	;Affect
+l1 :	mov	r1,	1	;Affect
+	cmp	r2,	1	;JumpIfLess 1
+	jl	l0	;JumpIfLess 2
+	mov	r1,	0	;Affect
+l0 :	mov	eax,	r1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/pre-nasm-ref/mult1.pre-nasm b/test/pre-nasm-ref/mult1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1986d14e99fd6413fb9eefae9b2330619e6456d7
--- /dev/null
+++ b/test/pre-nasm-ref/mult1.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	2
+	imul	@1,	3
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/mult2.pre-nasm b/test/pre-nasm-ref/mult2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..28d48a3b88e06ee39a96ad70965f1c3989361ff5
--- /dev/null
+++ b/test/pre-nasm-ref/mult2.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	0
+	imul	@1,	321
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/mult3.pre-nasm b/test/pre-nasm-ref/mult3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..d9fbcbfa6b97564ff9538ab85c815a1e9c0e22de
--- /dev/null
+++ b/test/pre-nasm-ref/mult3.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	3
+	imul	@1,	3
+	mov	@2,	@1
+	imul	@2,	2
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/not1.pre-nasm b/test/pre-nasm-ref/not1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..eb7b79fa8b7b1d2db8942909986bdf0e154910f9
--- /dev/null
+++ b/test/pre-nasm-ref/not1.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	1	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/not2.pre-nasm b/test/pre-nasm-ref/not2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2c7a875fad04782613a4720f599a61096add6925
--- /dev/null
+++ b/test/pre-nasm-ref/not2.pre-nasm
@@ -0,0 +1,35 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	mov	@8,	0	;JumpIfEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/not3.pre-nasm b/test/pre-nasm-ref/not3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f523d4f60a877729ef863a3f1a60623a9a203481
--- /dev/null
+++ b/test/pre-nasm-ref/not3.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	1	;Affect
+	mov	@9,	0	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@2,	0	;Affect
+l1 :	mov	@1,	1	;Affect
+	cmp	@2,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/or1.pre-nasm b/test/pre-nasm-ref/or1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2e6687614c1bd1d91c4c03f52646d3a6742ff6e4
--- /dev/null
+++ b/test/pre-nasm-ref/or1.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	1	;jumpIfNotEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@9,	1	;jumpIfNotEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/or2.pre-nasm b/test/pre-nasm-ref/or2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..600dd181e20fea10cfc8beb8bc63e6d483fe6897
--- /dev/null
+++ b/test/pre-nasm-ref/or2.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	1	;jumpIfNotEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@9,	0	;jumpIfNotEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/or3.pre-nasm b/test/pre-nasm-ref/or3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f34edd4ae4d67b2dec40ed2edb8da4e67c884c5d
--- /dev/null
+++ b/test/pre-nasm-ref/or3.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	0	;jumpIfNotEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@9,	1	;jumpIfNotEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/or4.pre-nasm b/test/pre-nasm-ref/or4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..becebcc19701bd45c79fdd3f44cfc1730cad7fec
--- /dev/null
+++ b/test/pre-nasm-ref/or4.pre-nasm
@@ -0,0 +1,39 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	0	;jumpIfNotEqual 1
+	cmp	@8,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@9,	0	;jumpIfNotEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/or5.pre-nasm b/test/pre-nasm-ref/or5.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..46e2785cb0cb91abca24b53648b05d420273b96e
--- /dev/null
+++ b/test/pre-nasm-ref/or5.pre-nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@9,	0	;jumpIfNotEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	jne	l3	;jumpIfNotEqual 2
+	mov	@10,	1	;jumpIfNotEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	jne	l3	;jumpIfNotEqual 2
+	mov	@2,	0	;Affect
+	jmp	l2	;Jump
+l3 :	mov	@2,	1	;Affect
+l2 :	cmp	@2,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	@11,	0	;jumpIfNotEqual 1
+	cmp	@11,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/parenth1.pre-nasm b/test/pre-nasm-ref/parenth1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..27b03b80c36b05cb2041895ba422f7d674f2b540
--- /dev/null
+++ b/test/pre-nasm-ref/parenth1.pre-nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/parenth2.pre-nasm b/test/pre-nasm-ref/parenth2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..8673e3935727a981e0fec8e8f2e18a336821872e
--- /dev/null
+++ b/test/pre-nasm-ref/parenth2.pre-nasm
@@ -0,0 +1,30 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	eax,	2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio23-1.pre-nasm b/test/pre-nasm-ref/prio23-1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..8011242044c9f3aa28b968b329998a24a7eed909
--- /dev/null
+++ b/test/pre-nasm-ref/prio23-1.pre-nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	r0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	r1,	1	;Affect
+	mov	r9,	0	;JumpIfEqual 1
+	cmp	r9,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	r1,	0	;Affect
+l0 :	mov	r2,	r1	;
+	imul	r2,	10	;
+	mov	eax,	r2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/pre-nasm-ref/prio23-2.pre-nasm b/test/pre-nasm-ref/prio23-2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..762181d13b6371a1b8b87bcd0d7a96c575c516dd
--- /dev/null
+++ b/test/pre-nasm-ref/prio23-2.pre-nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	r0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	r1,	1	;Affect
+	mov	r9,	10	;JumpIfEqual 1
+	cmp	r9,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	r1,	0	;Affect
+l0 :	mov	r2,	3	;
+	imul	r2,	r1	;
+	mov	eax,	r2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/pre-nasm-ref/prio23-3.pre-nasm b/test/pre-nasm-ref/prio23-3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2892dc2e2242915e04687493b5fea7785e727c2d
--- /dev/null
+++ b/test/pre-nasm-ref/prio23-3.pre-nasm
@@ -0,0 +1,41 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	r0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	r1,	1	;Affect
+	mov	r9,	0	;JumpIfEqual 1
+	cmp	r9,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	r1,	0	;Affect
+l0 :	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	r1	;affectation des bits de poids faible du dividende
+	mov	r12,	1	;
+	idiv	r12	;
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	r2,	eax	;
+	mov	eax,	r2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/pre-nasm-ref/prio23-4.pre-nasm b/test/pre-nasm-ref/prio23-4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..87dd906f38774319e773f04fc0b7c99d2e7df9d4
--- /dev/null
+++ b/test/pre-nasm-ref/prio23-4.pre-nasm
@@ -0,0 +1,45 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main	;
+	pop	r0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80	;
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	r1,	1	;Affect
+	mov	r10,	1	;JumpIfEqual 1
+	cmp	r10,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	r1,	0	;Affect
+l0 :	mov	r2,	1	;Affect
+	mov	r11,	0	;JumpIfEqual 1
+	cmp	r11,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	r2,	0	;Affect
+l1 :	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	r1	;affectation des bits de poids faible du dividende
+	idiv	r2	;
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	r3,	eax	;
+	mov	eax,	r3	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret	;
diff --git a/test/pre-nasm-ref/prio34-1.pre-nasm b/test/pre-nasm-ref/prio34-1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f2da2ea9fd6ed737c3d194d3d42bfd614d31b176
--- /dev/null
+++ b/test/pre-nasm-ref/prio34-1.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	3
+	imul	@1,	4
+	mov	@2,	2
+	add	@2,	@1
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio34-2.pre-nasm b/test/pre-nasm-ref/prio34-2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..b33bca19f590463fc894b9bec2139c12a034582f
--- /dev/null
+++ b/test/pre-nasm-ref/prio34-2.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	2
+	imul	@1,	3
+	mov	@2,	@1
+	sub	@2,	4
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio34-3.pre-nasm b/test/pre-nasm-ref/prio34-3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..844ca425a079f77797fa1f840954b9ddb67c11de
--- /dev/null
+++ b/test/pre-nasm-ref/prio34-3.pre-nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	6	;affectation des bits de poids faible du dividende
+	mov	@11,	3
+	idiv	@11
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	@2,	@1
+	sub	@2,	72
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio34-4.pre-nasm b/test/pre-nasm-ref/prio34-4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a7d271054f8e72de53df1001de4cb96899b55d79
--- /dev/null
+++ b/test/pre-nasm-ref/prio34-4.pre-nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	edx,	0	;mise à 0 des bits de poids fort du dividende
+	mov	eax,	20	;affectation des bits de poids faible du dividende
+	mov	@11,	10
+	idiv	@11
+	mov	edx,	edx	;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée
+	mov	@1,	eax
+	mov	@2,	6
+	add	@2,	@1
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio45-1.pre-nasm b/test/pre-nasm-ref/prio45-1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1fb4cb0005de6c1ce0dfc9ce58412ed20fc3ae5a
--- /dev/null
+++ b/test/pre-nasm-ref/prio45-1.pre-nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	0
+	add	@2,	1
+	mov	@1,	1	;Affect
+	mov	@9,	2	;JumpIfEqual 1
+	cmp	@9,	@2	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio45-2.pre-nasm b/test/pre-nasm-ref/prio45-2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..5e1095022b1c3d13ce896c5ebe25e85446be29af
--- /dev/null
+++ b/test/pre-nasm-ref/prio45-2.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	1
+	add	@2,	234
+	mov	@1,	1	;Affect
+	cmp	@2,	1	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio45-3.pre-nasm b/test/pre-nasm-ref/prio45-3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..d4ee4c1a548dafbb0a68addf94dfb538c67bd722
--- /dev/null
+++ b/test/pre-nasm-ref/prio45-3.pre-nasm
@@ -0,0 +1,37 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	11
+	add	@2,	100
+	mov	@1,	1	;Affect
+	mov	@9,	12	;JumpIfLess 1
+	cmp	@9,	@2	;on passe par un registre temporaire
+	jl	l0	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio45-4.pre-nasm b/test/pre-nasm-ref/prio45-4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..3ffda465db48ea9cb2e0621bcc42beba2eedea3b
--- /dev/null
+++ b/test/pre-nasm-ref/prio45-4.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	21
+	sub	@2,	21
+	mov	@1,	1	;Affect
+	cmp	@2,	1	;JumpIfLess 1
+	jl	l0	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio56-1.pre-nasm b/test/pre-nasm-ref/prio56-1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..add9a0d94ae76b4ed31eeb612141e1b856b3b6a9
--- /dev/null
+++ b/test/pre-nasm-ref/prio56-1.pre-nasm
@@ -0,0 +1,43 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	1	;Affect
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	2	;on passe par un registre temporaire
+	je	l2	;JumpIfEqual 2
+	mov	@2,	0	;Affect
+l2 :	cmp	@2,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	@10,	1	;JumpIfEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	@1,	1	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	0	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio56-2.pre-nasm b/test/pre-nasm-ref/prio56-2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..563d1d62fd5d23b67f97e13012201f6362b72b98
--- /dev/null
+++ b/test/pre-nasm-ref/prio56-2.pre-nasm
@@ -0,0 +1,43 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@2,	1	;Affect
+	mov	@9,	0	;JumpIfEqual 1
+	cmp	@9,	1	;on passe par un registre temporaire
+	je	l2	;JumpIfEqual 2
+	mov	@2,	0	;Affect
+l2 :	mov	@10,	1	;jumpIfNotEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	cmp	@2,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio67-1.pre-nasm b/test/pre-nasm-ref/prio67-1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..b615ead245c061eb36b70a107530cd6a2f22a06b
--- /dev/null
+++ b/test/pre-nasm-ref/prio67-1.pre-nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@9,	0	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@10,	1	;JumpIfEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@2,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	@2,	0	;Affect
+l2 :	cmp	@2,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	@11,	1	;jumpIfNotEqual 1
+	cmp	@11,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/prio67-2.pre-nasm b/test/pre-nasm-ref/prio67-2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..872c0592661fce73b40931a9983776caa350e4ae
--- /dev/null
+++ b/test/pre-nasm-ref/prio67-2.pre-nasm
@@ -0,0 +1,47 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@10,	0	;JumpIfEqual 1
+	cmp	@10,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	@2,	1	;Affect
+	jmp	l2	;Jump
+l3 :	mov	@2,	0	;Affect
+l2 :	mov	@11,	1	;jumpIfNotEqual 1
+	cmp	@11,	0	;on passe par un registre temporaire
+	jne	l1	;jumpIfNotEqual 2
+	cmp	@2,	0	;jumpIfNotEqual 1
+	jne	l1	;jumpIfNotEqual 2
+	mov	@1,	0	;Affect
+	jmp	l0	;Jump
+l1 :	mov	@1,	1	;Affect
+l0 :	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/rec1.pre-nasm b/test/pre-nasm-ref/rec1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..0e66dc7a641f9983636dd1aed479de7d19fc006e
--- /dev/null
+++ b/test/pre-nasm-ref/rec1.pre-nasm
@@ -0,0 +1,81 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	1	;Affect
+	cmp	dword [ebp+12],	1	;JumpIfEqual 1
+	je	l2	;JumpIfEqual 2
+	mov	@1,	0	;Affect
+l2 :	cmp	@1,	0	;JumpIfEqual 1
+	je	l0	;JumpIfEqual 2
+	mov	dword [ebp+8],	1	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+	jmp	l1	;Jump
+l0 :	mov	@3,	dword [ebp+12]
+	sub	@3,	1
+	push	@3	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@2	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	@4,	1
+	add	@4,	@2
+	mov	dword [ebp+8],	@4	;ecriture de la valeur de retour
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	push	100	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@5	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	mov	eax,	@5	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/si1.pre-nasm b/test/pre-nasm-ref/si1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..dc1e313e7eccac85ada45bbee22bcf6ceceb54f4
--- /dev/null
+++ b/test/pre-nasm-ref/si1.pre-nasm
@@ -0,0 +1,33 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	1	;JumpIfEqual 1
+	cmp	@7,	0	;on passe par un registre temporaire
+	je	l1	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/si2.pre-nasm b/test/pre-nasm-ref/si2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..4836fc5ca0b4c69c449a2f584ee2a7d246462886
--- /dev/null
+++ b/test/pre-nasm-ref/si2.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	0	;JumpIfEqual 1
+	cmp	@7,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/si3.pre-nasm b/test/pre-nasm-ref/si3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..c8bc79555743344c7f60bf3b113d3c5824d1d2f9
--- /dev/null
+++ b/test/pre-nasm-ref/si3.pre-nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	1	;JumpIfEqual 1
+	cmp	@7,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/si4.pre-nasm b/test/pre-nasm-ref/si4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cac66d9105bed7eb1be97831d0f7bcbd3e0ce898
--- /dev/null
+++ b/test/pre-nasm-ref/si4.pre-nasm
@@ -0,0 +1,38 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	0	;JumpIfEqual 1
+	cmp	@7,	0	;on passe par un registre temporaire
+	je	l0	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	jmp	l1	;Jump
+l0 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+l1 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/si5.pre-nasm b/test/pre-nasm-ref/si5.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..1fda832b182dd5e919e04a014c6630f0ffb9d287
--- /dev/null
+++ b/test/pre-nasm-ref/si5.pre-nasm
@@ -0,0 +1,40 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	1	;JumpIfEqual 1
+	cmp	@7,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	mov	@9,	1	;JumpIfEqual 1
+	cmp	@9,	0	;on passe par un registre temporaire
+	je	l3	;JumpIfEqual 2
+	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+l3 :	mov	eax,	1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/sub1.pre-nasm b/test/pre-nasm-ref/sub1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..450082532dd19fa708c3105ce0faac6978f0035b
--- /dev/null
+++ b/test/pre-nasm-ref/sub1.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	10
+	sub	@1,	5
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/sub2.pre-nasm b/test/pre-nasm-ref/sub2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..4a4dd72cc385f2ca13fd72b59f4898b7d644fc0e
--- /dev/null
+++ b/test/pre-nasm-ref/sub2.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	7
+	sub	@1,	20
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/sub3.pre-nasm b/test/pre-nasm-ref/sub3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..3d2edcbdf79f63398e00047bf18970715834898d
--- /dev/null
+++ b/test/pre-nasm-ref/sub3.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@1,	2
+	sub	@1,	1
+	mov	@2,	@1
+	sub	@2,	1
+	mov	eax,	@2	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tab1.pre-nasm b/test/pre-nasm-ref/tab1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..d43656949862e9bf07990cf4e33bfd1fbfcaf850
--- /dev/null
+++ b/test/pre-nasm-ref/tab1.pre-nasm
@@ -0,0 +1,50 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	12	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@7,	0
+	imul	@7,	4
+	mov	dword [tab+@7],	0	;Affect
+	mov	@8,	1
+	imul	@8,	4
+	mov	dword [tab+@8],	1	;Affect
+	mov	@9,	2
+	imul	@9,	4
+	mov	dword [tab+@9],	2	;Affect
+	mov	@11,	0
+	imul	@11,	4
+	mov	eax,	dword [tab+@11]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@13,	1
+	imul	@13,	4
+	mov	eax,	dword [tab+@13]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@15,	2
+	imul	@15,	4
+	mov	eax,	dword [tab+@15]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tab2.pre-nasm b/test/pre-nasm-ref/tab2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..cd9d7e35d13eef4ef7abd4861af0ea87106e684c
--- /dev/null
+++ b/test/pre-nasm-ref/tab2.pre-nasm
@@ -0,0 +1,57 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	20	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	2	;Affect
+	mov	@1,	dword [ebp-4]
+	add	@1,	0
+	mov	@10,	@1
+	imul	@10,	4
+	mov	dword [tab+@10],	34	;Affect
+	mov	@2,	dword [ebp-4]
+	add	@2,	1
+	mov	@11,	@2
+	imul	@11,	4
+	mov	dword [tab+@11],	74	;Affect
+	mov	@3,	dword [ebp-4]
+	add	@3,	2
+	mov	@12,	@3
+	imul	@12,	4
+	mov	dword [tab+@12],	16	;Affect
+	mov	@14,	2
+	imul	@14,	4
+	mov	eax,	dword [tab+@14]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@16,	3
+	imul	@16,	4
+	mov	eax,	dword [tab+@16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@18,	4
+	imul	@18,	4
+	mov	eax,	dword [tab+@18]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tab3.pre-nasm b/test/pre-nasm-ref/tab3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..f285d1a80d2c9fd7dc117d7ae6726a8c844c4ef6
--- /dev/null
+++ b/test/pre-nasm-ref/tab3.pre-nasm
@@ -0,0 +1,60 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	20	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	2	;Affect
+	mov	dword [ebp-8],	0	;Affect
+	mov	@1,	dword [ebp-4]
+	add	@1,	dword [ebp-8]
+	mov	@10,	@1
+	imul	@10,	4
+	mov	dword [tab+@10],	34	;Affect
+	mov	dword [ebp-8],	1	;Affect
+	mov	@2,	dword [ebp-4]
+	add	@2,	dword [ebp-8]
+	mov	@11,	@2
+	imul	@11,	4
+	mov	dword [tab+@11],	74	;Affect
+	mov	dword [ebp-8],	2	;Affect
+	mov	@3,	dword [ebp-4]
+	add	@3,	dword [ebp-8]
+	mov	@12,	@3
+	imul	@12,	4
+	mov	dword [tab+@12],	16	;Affect
+	mov	@14,	2
+	imul	@14,	4
+	mov	eax,	dword [tab+@14]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@16,	3
+	imul	@16,	4
+	mov	eax,	dword [tab+@16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@18,	4
+	imul	@18,	4
+	mov	eax,	dword [tab+@18]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tab4.pre-nasm b/test/pre-nasm-ref/tab4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..19f610c2a0c84dbcc95f83ae92eaec73baf1f490
--- /dev/null
+++ b/test/pre-nasm-ref/tab4.pre-nasm
@@ -0,0 +1,56 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	12	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@8,	0
+	imul	@8,	4
+	mov	dword [tab+@8],	1	;Affect
+	mov	@10,	0
+	imul	@10,	4
+	mov	@9,	dword [tab+@10]
+	imul	@9,	4
+	mov	dword [tab+@9],	12	;Affect
+	mov	@11,	0
+	imul	@11,	4
+	mov	@1,	dword [tab+@11]
+	add	@1,	1
+	mov	@12,	@1
+	imul	@12,	4
+	mov	dword [tab+@12],	13	;Affect
+	mov	@14,	0
+	imul	@14,	4
+	mov	eax,	dword [tab+@14]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@16,	1
+	imul	@16,	4
+	mov	eax,	dword [tab+@16]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@18,	2
+	imul	@18,	4
+	mov	eax,	dword [tab+@18]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tantque1.pre-nasm b/test/pre-nasm-ref/tantque1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..fa993f893fc6cb3ac1663d68defa6b1ac252ce38
--- /dev/null
+++ b/test/pre-nasm-ref/tantque1.pre-nasm
@@ -0,0 +1,44 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+l0 :	mov	@1,	1	;Affect
+	mov	@9,	0	;JumpIfLess 1
+	cmp	@9,	dword [ebp-4]	;on passe par un registre temporaire
+	jl	l2	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l2 :	cmp	@1,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@2,	dword [ebp-4]
+	sub	@2,	1
+	mov	dword [ebp-4],	@2	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tantque2.pre-nasm b/test/pre-nasm-ref/tantque2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..02a466d1eaa2d6c993af18866fd8dedb00b89634
--- /dev/null
+++ b/test/pre-nasm-ref/tantque2.pre-nasm
@@ -0,0 +1,54 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	0	;Affect
+l0 :	mov	@1,	1	;Affect
+	cmp	dword [ebp-4],	4	;JumpIfLess 1
+	jl	l2	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l2 :	cmp	@1,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	dword [ebp-8],	0	;Affect
+l3 :	mov	@2,	1	;Affect
+	cmp	dword [ebp-8],	4	;JumpIfLess 1
+	jl	l5	;JumpIfLess 2
+	mov	@2,	0	;Affect
+l5 :	cmp	@2,	0	;JumpIfEqual 1
+	je	l4	;JumpIfEqual 2
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-8]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@3,	dword [ebp-8]
+	add	@3,	1
+	mov	dword [ebp-8],	@3	;Affect
+	jmp	l3	;Jump
+l4 :	mov	@4,	dword [ebp-4]
+	add	@4,	1
+	mov	dword [ebp-4],	@4	;Affect
+	jmp	l0	;Jump
+l1 :	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/tri.pre-nasm b/test/pre-nasm-ref/tri.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..382fef787c9d3964b737375294a5561ee757f004
--- /dev/null
+++ b/test/pre-nasm-ref/tri.pre-nasm
@@ -0,0 +1,214 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+tab :	resd	40	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+initialiser :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	@22,	0
+	imul	@22,	4
+	mov	dword [tab+@22],	8	;Affect
+	mov	@23,	1
+	imul	@23,	4
+	mov	dword [tab+@23],	6	;Affect
+	mov	@24,	2
+	imul	@24,	4
+	mov	dword [tab+@24],	9	;Affect
+	mov	@25,	3
+	imul	@25,	4
+	mov	dword [tab+@25],	9	;Affect
+	mov	@26,	4
+	imul	@26,	4
+	mov	dword [tab+@26],	4	;Affect
+	mov	@27,	5
+	imul	@27,	4
+	mov	dword [tab+@27],	2	;Affect
+	mov	@28,	6
+	imul	@28,	4
+	mov	dword [tab+@28],	3	;Affect
+	mov	@29,	7
+	imul	@29,	4
+	mov	dword [tab+@29],	1	;Affect
+	mov	@30,	8
+	imul	@30,	4
+	mov	dword [tab+@30],	4	;Affect
+	mov	@31,	9
+	imul	@31,	4
+	mov	dword [tab+@31],	5	;Affect
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+afficher :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	0	;Affect
+l0 :	mov	@1,	1	;Affect
+	mov	@40,	dword [ebp-4]	;JumpIfLess 1
+	cmp	@40,	dword [ebp+12]	;on passe par un registre temporaire
+	jl	l2	;JumpIfLess 2
+	mov	@1,	0	;Affect
+l2 :	cmp	@1,	0	;JumpIfEqual 1
+	je	l1	;JumpIfEqual 2
+	mov	@42,	dword [ebp-4]
+	imul	@42,	4
+	mov	eax,	dword [tab+@42]	;Write 1
+	call	iprintLF	;Write 2
+	mov	@2,	dword [ebp-4]
+	add	@2,	1
+	mov	dword [ebp-4],	@2	;Affect
+	jmp	l0	;Jump
+l1 :	mov	eax,	0	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+echanger :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	@52,	dword [ebp+12]
+	imul	@52,	4
+	mov	@53,	dword [tab+@52]	;Affect
+	mov	dword [ebp-4],	@53	;on passe par un registre temporaire
+	mov	@54,	dword [ebp+16]
+	imul	@54,	4
+	mov	@55,	dword [ebp+12]
+	imul	@55,	4
+	mov	@56,	dword [tab+@54]	;Affect
+	mov	dword [tab+@55],	@56	;on passe par un registre temporaire
+	mov	@57,	dword [ebp+16]
+	imul	@57,	4
+	mov	@58,	dword [ebp-4]	;Affect
+	mov	dword [tab+@57],	@58	;on passe par un registre temporaire
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+trier :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	12	;allocation des variables locales
+	mov	@67,	dword [ebp+12]	;Affect
+	mov	dword [ebp-12],	@67	;on passe par un registre temporaire
+	mov	dword [ebp-4],	1	;Affect
+l3 :	mov	@3,	1	;Affect
+	cmp	dword [ebp-4],	1	;JumpIfEqual 1
+	je	l5	;JumpIfEqual 2
+	mov	@3,	0	;Affect
+l5 :	cmp	@3,	0	;JumpIfEqual 1
+	je	l4	;JumpIfEqual 2
+	mov	dword [ebp-4],	0	;Affect
+	mov	dword [ebp-8],	0	;Affect
+l6 :	mov	@5,	dword [ebp-12]
+	sub	@5,	1
+	mov	@4,	1	;Affect
+	cmp	dword [ebp-8],	@5	;JumpIfLess 1
+	jl	l8	;JumpIfLess 2
+	mov	@4,	0	;Affect
+l8 :	cmp	@4,	0	;JumpIfEqual 1
+	je	l7	;JumpIfEqual 2
+	mov	@7,	dword [ebp-8]
+	add	@7,	1
+	mov	@6,	1	;Affect
+	mov	@68,	@7
+	imul	@68,	4
+	mov	@69,	dword [ebp-8]
+	imul	@69,	4
+	mov	@70,	dword [tab+@68]	;JumpIfLess 1
+	cmp	@70,	dword [tab+@69]	;on passe par un registre temporaire
+	jl	l11	;JumpIfLess 2
+	mov	@6,	0	;Affect
+l11 :	cmp	@6,	0	;JumpIfEqual 1
+	je	l10	;JumpIfEqual 2
+	push	dword [ebp-8]	;Param
+	mov	@9,	dword [ebp-8]
+	add	@9,	1
+	push	@9	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	echanger
+	pop	@8	;récupération de la valeur de retour
+	add	esp,	8	;désallocation des arguments
+	mov	dword [ebp-4],	1	;Affect
+l10 :	mov	@10,	dword [ebp-8]
+	add	@10,	1
+	mov	dword [ebp-8],	@10	;Affect
+	jmp	l6	;Jump
+l7 :	mov	@11,	dword [ebp-12]
+	sub	@11,	1
+	mov	dword [ebp-12],	@11	;Affect
+	jmp	l3	;Jump
+l4 :	add	esp,	12	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	initialiser
+	pop	@12	;récupération de la valeur de retour
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	afficher
+	pop	@13	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	trier
+	pop	@14	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	push	10	;Param
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	afficher
+	pop	@15	;récupération de la valeur de retour
+	add	esp,	4	;désallocation des arguments
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varglob1.pre-nasm b/test/pre-nasm-ref/varglob1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..99d5927ee499b346e4134460ca6f6ea467f3289a
--- /dev/null
+++ b/test/pre-nasm-ref/varglob1.pre-nasm
@@ -0,0 +1,32 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+variable :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [variable],	6834	;Affect
+	mov	eax,	dword [variable]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varglob2.pre-nasm b/test/pre-nasm-ref/varglob2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..a4e84c3f93cebf257dc71c9b2a7e8444935d1c4c
--- /dev/null
+++ b/test/pre-nasm-ref/varglob2.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+variable :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [variable],	10	;Affect
+	mov	@1,	dword [variable]
+	add	@1,	50
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varglob3.pre-nasm b/test/pre-nasm-ref/varglob3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..8523503287bffbb378532cb427d89138356ffa0c
--- /dev/null
+++ b/test/pre-nasm-ref/varglob3.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var2 :	resd	4	;variable globale
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	10	;Affect
+	mov	dword [var2],	34	;Affect
+	mov	eax,	dword [var1]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [var2]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varglob4.pre-nasm b/test/pre-nasm-ref/varglob4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..8ca2926899c4c8891fa881b9952c214323cb35c6
--- /dev/null
+++ b/test/pre-nasm-ref/varglob4.pre-nasm
@@ -0,0 +1,36 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var2 :	resd	4	;variable globale
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	10	;Affect
+	mov	dword [var2],	34	;Affect
+	mov	@1,	dword [var1]
+	add	@1,	dword [var2]
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varloc1.pre-nasm b/test/pre-nasm-ref/varloc1.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..2b2479ef1ef840364e54834d4f9fcf6e61a1c646
--- /dev/null
+++ b/test/pre-nasm-ref/varloc1.pre-nasm
@@ -0,0 +1,31 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	6834	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varloc2.pre-nasm b/test/pre-nasm-ref/varloc2.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..8c40b7483b72a6abe237f84baa7a6752983ed421
--- /dev/null
+++ b/test/pre-nasm-ref/varloc2.pre-nasm
@@ -0,0 +1,33 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	@1,	dword [ebp-4]
+	add	@1,	50
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varloc3.pre-nasm b/test/pre-nasm-ref/varloc3.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..bd7329d3af5b9d55c4448862e1aab5f6e2ddac60
--- /dev/null
+++ b/test/pre-nasm-ref/varloc3.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	dword [ebp-8],	30	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	mov	eax,	dword [ebp-8]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varloc4.pre-nasm b/test/pre-nasm-ref/varloc4.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..01d032c019e8e41a056c0f86b9ead53f0e1c6707
--- /dev/null
+++ b/test/pre-nasm-ref/varloc4.pre-nasm
@@ -0,0 +1,34 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	8	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	dword [ebp-8],	30	;Affect
+	mov	@1,	dword [ebp-4]
+	add	@1,	dword [ebp-8]
+	mov	eax,	@1	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	8	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/pre-nasm-ref/varloc5.pre-nasm b/test/pre-nasm-ref/varloc5.pre-nasm
new file mode 100644
index 0000000000000000000000000000000000000000..613c517bedc2545988823f6d7cdd901c3833d577
--- /dev/null
+++ b/test/pre-nasm-ref/varloc5.pre-nasm
@@ -0,0 +1,52 @@
+%include	'io.asm'
+
+section	.bss
+sinput :	resb	255	;reserve a 255 byte space in memory for the users input string
+var1 :	resd	4	;variable globale
+
+section	.text
+global _start
+_start:
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	main
+	pop	@0	;récupération de la valeur de retour
+	mov	ebx,	0	; valeur de retour du programme
+	mov	eax,	1	; code de sortie
+	int 0x80
+f :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	4	;allocation des variables locales
+	mov	dword [ebp-4],	10	;Affect
+	mov	eax,	dword [ebp-4]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	4	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
+main :	push	ebp	;sauvegarde la valeur de ebp
+	mov	ebp,	esp	;nouvelle valeur de ebp
+	push	eax	;sauvegarde de eax
+	push	ebx	;sauvegarde de ebx
+	push	ecx	;sauvegarde de ecx
+	push	edx	;sauvegarde de edx
+	sub	esp,	0	;allocation des variables locales
+	mov	dword [var1],	20	;Affect
+	sub	esp,	4	;allocation mémoire pour la valeur de retour
+	call	f
+	pop	@1	;récupération de la valeur de retour
+	mov	eax,	dword [var1]	;Write 1
+	call	iprintLF	;Write 2
+	add	esp,	0	;désallocation des variables locales
+	pop	edx	;restaure edx
+	pop	ecx	;restaure ecx
+	pop	ebx	;restaure ebx
+	pop	eax	;restaure eax
+	pop	ebp	;restaure la valeur de ebp
+	ret
diff --git a/test/sa-ref/add1.sa b/test/sa-ref/add1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..5d44ab11b03a062bf0134603fbbb0c6f35ab5c64
--- /dev/null
+++ b/test/sa-ref/add1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 3 10)) null))) null))
diff --git a/test/sa-ref/add2.sa b/test/sa-ref/add2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..1eaaf82fdcb6c0d4fa12b8befaab428a9915f2eb
--- /dev/null
+++ b/test/sa-ref/add2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd (SaExpAdd 2 4) 8)) null))) null))
diff --git a/test/sa-ref/affect1.sa b/test/sa-ref/affect1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f1ab7208f592c7b47ea9534dd53e3122e90cae15
--- /dev/null
+++ b/test/sa-ref/affect1.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple a entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) null))
diff --git a/test/sa-ref/affect2.sa b/test/sa-ref/affect2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..c385bfe89cd45f054cd9c70164097f757e8c12ee
--- /dev/null
+++ b/test/sa-ref/affect2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) null))
diff --git a/test/sa-ref/affect3.sa b/test/sa-ref/affect3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..8a9fc32b66bd46039e3535562f68e7038e4daa41
--- /dev/null
+++ b/test/sa-ref/affect3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaAppel f (SaLExp 3 null)) null))) null)))
diff --git a/test/sa-ref/and1.sa b/test/sa-ref/and1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..441514f4e1150542e72fc192c919f438b3dc9d2e
--- /dev/null
+++ b/test/sa-ref/and1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd vrai vrai)) null))) null))
diff --git a/test/sa-ref/and2.sa b/test/sa-ref/and2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..b973e3f11a92d12fbf11f5f38277c8bcd34f0de9
--- /dev/null
+++ b/test/sa-ref/and2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd vrai faux)) null))) null))
diff --git a/test/sa-ref/and3.sa b/test/sa-ref/and3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..64e377e1160d9532d23add2134eb8662f49c1970
--- /dev/null
+++ b/test/sa-ref/and3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd faux vrai)) null))) null))
diff --git a/test/sa-ref/and4.sa b/test/sa-ref/and4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..af3a8c1d5ce613ecccd23f6ba99f0b775c5b3002
--- /dev/null
+++ b/test/sa-ref/and4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd faux faux)) null))) null))
diff --git a/test/sa-ref/and5.sa b/test/sa-ref/and5.sa
new file mode 100644
index 0000000000000000000000000000000000000000..67fbb823330032d3e8cd89411ffdc329b0267339
--- /dev/null
+++ b/test/sa-ref/and5.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd (SaExpAnd vrai faux) vrai)) null))) null))
diff --git a/test/sa-ref/appel-param1.sa b/test/sa-ref/appel-param1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f8f48cd884cbe2311d72fca6d1d9b7bb8c83b625
--- /dev/null
+++ b/test/sa-ref/appel-param1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 null)) null))) null)))
diff --git a/test/sa-ref/appel-param2.sa b/test/sa-ref/appel-param2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f39770f04095f69d29ee6bb57a03cf2ac64a400d
--- /dev/null
+++ b/test/sa-ref/appel-param2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) null)) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 (SaLExp 456 null))) null))) null)))
diff --git a/test/sa-ref/appel-param3.sa b/test/sa-ref/appel-param3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d022a660831ee0d6a5fc29fb3dab2362c07d1d49
--- /dev/null
+++ b/test/sa-ref/appel-param3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) (SaLDecVar (SaDecVarSimple c entier) (SaLDecVar (SaDecVarSimple d entier) (SaLDecVar (SaDecVarSimple e entier) null))))) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple c))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple d))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple e))) null))))))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 (SaLExp 2 (SaLExp 3 (SaLExp 4 (SaLExp 5 null)))))) null))) null)))
diff --git a/test/sa-ref/appel-retour1.sa b/test/sa-ref/appel-retour1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..7bb6f84b0cc95392702d6926853b193c52850908
--- /dev/null
+++ b/test/sa-ref/appel-retour1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f entier (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstRetour (SaExpVar (SaVarSimple a))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel f (SaLExp 3712 null)))) null))) null)))
diff --git a/test/sa-ref/appel1.sa b/test/sa-ref/appel1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..6de41b4ac5ca235a860b690958363f270c388a0d
--- /dev/null
+++ b/test/sa-ref/appel1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) null))) null)))
diff --git a/test/sa-ref/appel2.sa b/test/sa-ref/appel2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..891435b8db7dad99448c4ade7cf3b012bf327917
--- /dev/null
+++ b/test/sa-ref/appel2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc g nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) (SaLInst (SaAppel g null) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) null))) null))))
diff --git a/test/sa-ref/appel3.sa b/test/sa-ref/appel3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..63ad386965f745e2a0584683b96341610a683330
--- /dev/null
+++ b/test/sa-ref/appel3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc g nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) (SaLInst (SaAppel g null) null)))) null))))
diff --git a/test/sa-ref/div1.sa b/test/sa-ref/div1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..c6889353bd72d014dfeec455910cee85a296de3a
--- /dev/null
+++ b/test/sa-ref/div1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 4 2)) null))) null))
diff --git a/test/sa-ref/div2.sa b/test/sa-ref/div2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d50316670264ff5f39d39f243cafee0593aa6b29
--- /dev/null
+++ b/test/sa-ref/div2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 0 712)) null))) null))
diff --git a/test/sa-ref/div3.sa b/test/sa-ref/div3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..a2c6e4c31a4c5b2afe5fcb1e01bf4620309f4472
--- /dev/null
+++ b/test/sa-ref/div3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv (SaExpDiv 4 2) 2)) null))) null))
diff --git a/test/sa-ref/div4.sa b/test/sa-ref/div4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..08acfe919c01e010c234d4f2b9a99982558ec1fd
--- /dev/null
+++ b/test/sa-ref/div4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 2 3)) null))) null))
diff --git a/test/sa-ref/ecrire1.sa b/test/sa-ref/ecrire1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..49def4af8fbda32f70ffb75f5c62828b23a46cf9
--- /dev/null
+++ b/test/sa-ref/ecrire1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 3456) null))) null))
diff --git a/test/sa-ref/ecrire2.sa b/test/sa-ref/ecrire2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..1e1054c6d3d790445975a80d4f20caa9466fff04
--- /dev/null
+++ b/test/sa-ref/ecrire2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 0) null))) null))
diff --git a/test/sa-ref/egal1.sa b/test/sa-ref/egal1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..14530786f743ce47a7394e56d4f1c43132dc17a0
--- /dev/null
+++ b/test/sa-ref/egal1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 123 123)) null))) null))
diff --git a/test/sa-ref/egal2.sa b/test/sa-ref/egal2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d049f597ee94fd4878e8738e62992fd4455e6a5c
--- /dev/null
+++ b/test/sa-ref/egal2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 412 34)) null))) null))
diff --git a/test/sa-ref/egal3.sa b/test/sa-ref/egal3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..cb1c0c48b6205e64c266e3837863ac1ebc87dd98
--- /dev/null
+++ b/test/sa-ref/egal3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual (SaExpEqual 2 2) vrai)) null))) null))
diff --git a/test/sa-ref/err1.sa b/test/sa-ref/err1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..c79606334c992a2311ad9b0ca671f0c0e55e807d
--- /dev/null
+++ b/test/sa-ref/err1.sa
@@ -0,0 +1,18 @@
+<SaProg>
+ <SaLDec>
+  <SaDecFonc>
+   <nom>main</nom>
+   <SaInstBloc>
+    <SaLInst>
+     <SaInstEcriture>
+      <SaExpVar>
+       <SaVarSimple>
+        <nom>var1</nom>
+       </SaVarSimple>
+      </SaExpVar>
+     </SaInstEcriture>
+    </SaLInst>
+   </SaInstBloc>
+  </SaDecFonc>
+ </SaLDec>
+</SaProg>
diff --git a/test/sa-ref/err2.sa b/test/sa-ref/err2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..4409c766f57d3c471793c2cb137a53fac501be01
--- /dev/null
+++ b/test/sa-ref/err2.sa
@@ -0,0 +1,13 @@
+<SaProg>
+ <SaLDec>
+  <SaDecFonc>
+   <nom>main</nom>
+   <SaInstBloc>
+    <SaLInst>
+     <SaAppel>
+     </SaAppel>
+    </SaLInst>
+   </SaInstBloc>
+  </SaDecFonc>
+ </SaLDec>
+</SaProg>
diff --git a/test/sa-ref/err3.sa b/test/sa-ref/err3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..5b42731bb69caed04433b75311662ee679760a3b
--- /dev/null
+++ b/test/sa-ref/err3.sa
@@ -0,0 +1,23 @@
+<SaProg>
+ <SaLDec>
+  <SaDecFonc>
+   <nom>f</nom>
+   <SaLDec>
+    <SaDecVar>
+     <nom>a</nom>
+    </SaDecVar>
+   </SaLDec>
+  </SaDecFonc>
+  <SaLDec>
+   <SaDecFonc>
+    <nom>main</nom>
+    <SaInstBloc>
+     <SaLInst>
+      <SaAppel>
+      </SaAppel>
+     </SaLInst>
+    </SaInstBloc>
+   </SaDecFonc>
+  </SaLDec>
+ </SaLDec>
+</SaProg>
diff --git a/test/sa-ref/err4.sa b/test/sa-ref/err4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..2044b50bcccb4a17930f9c06cec242eb4f051cf7
--- /dev/null
+++ b/test/sa-ref/err4.sa
@@ -0,0 +1,33 @@
+<SaProg>
+ <SaLDec>
+  <SaDecFonc>
+   <nom>f</nom>
+   <SaLDec>
+    <SaDecVar>
+     <nom>a</nom>
+    </SaDecVar>
+   </SaLDec>
+   <SaLDec>
+    <SaDecVar>
+     <nom>a</nom>
+    </SaDecVar>
+   </SaLDec>
+  </SaDecFonc>
+  <SaLDec>
+   <SaDecFonc>
+    <nom>main</nom>
+    <SaInstBloc>
+     <SaLInst>
+      <SaAppel>
+       <SaLExp>
+        <SaExpInt>
+         <val>1</val>
+        </SaExpInt>
+       </SaLExp>
+      </SaAppel>
+     </SaLInst>
+    </SaInstBloc>
+   </SaDecFonc>
+  </SaLDec>
+ </SaLDec>
+</SaProg>
diff --git a/test/sa-ref/err5.sa b/test/sa-ref/err5.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f8226c89e651412482da82f23da12b000105b81f
--- /dev/null
+++ b/test/sa-ref/err5.sa
@@ -0,0 +1,39 @@
+<SaProg>
+ <SaLDec>
+  <SaDecFonc>
+   <nom>f</nom>
+   <SaInstBloc>
+    <SaLInst>
+     <SaInstEcriture>
+      <SaExpInt>
+       <val>1</val>
+      </SaExpInt>
+     </SaInstEcriture>
+    </SaLInst>
+   </SaInstBloc>
+  </SaDecFonc>
+  <SaLDec>
+   <SaDecFonc>
+    <nom>main</nom>
+    <SaLDec>
+     <SaDecVar>
+      <nom>f</nom>
+     </SaDecVar>
+    </SaLDec>
+    <SaInstBloc>
+     <SaLInst>
+      <SaInstAffect>
+       <SaVarSimple>
+        <nom>f</nom>
+       </SaVarSimple>
+       <SaExpAppel>
+        <SaAppel>
+        </SaAppel>
+       </SaExpAppel>
+      </SaInstAffect>
+     </SaLInst>
+    </SaInstBloc>
+   </SaDecFonc>
+  </SaLDec>
+ </SaLDec>
+</SaProg>
diff --git a/test/sa-ref/fibo.sa b/test/sa-ref/fibo.sa
new file mode 100644
index 0000000000000000000000000000000000000000..407ebdef6012000c38432bb735959ffea8990f7a
--- /dev/null
+++ b/test/sa-ref/fibo.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc fibo entier (SaLDecVar (SaDecVarSimple n entier) null) null (SaInstBloc (SaLInst (SaInstSi (SaExpInf (SaExpVar (SaVarSimple n)) 2) (SaInstBloc (SaLInst (SaInstRetour 1) null)) (SaInstBloc (SaLInst (SaInstRetour (SaExpAdd (SaExpAppel (SaAppel fibo (SaLExp (SaExpSub (SaExpVar (SaVarSimple n)) 1) null))) (SaExpAppel (SaAppel fibo (SaLExp (SaExpSub (SaExpVar (SaVarSimple n)) 2) null))))) null))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel fibo (SaLExp 9 null)))) null))) null)))
diff --git a/test/sa-ref/inf1.sa b/test/sa-ref/inf1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f5a5868546c9f4141df441433d0d1a2d661f4f99
--- /dev/null
+++ b/test/sa-ref/inf1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 3 3)) null))) null))
diff --git a/test/sa-ref/inf2.sa b/test/sa-ref/inf2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..c66c6659c3e1ee7ef7f89d79687130f29247ef07
--- /dev/null
+++ b/test/sa-ref/inf2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 4 1)) null))) null))
diff --git a/test/sa-ref/inf3.sa b/test/sa-ref/inf3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..30eb35c37a7e93c13cec9eed78bcc6418d98f94b
--- /dev/null
+++ b/test/sa-ref/inf3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 312 475)) null))) null))
diff --git a/test/sa-ref/inf4.sa b/test/sa-ref/inf4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..58c322dd28d8ecdba85879bdace80d4c21f4275d
--- /dev/null
+++ b/test/sa-ref/inf4.sa
@@ -0,0 +1,19 @@
+<programme type="SaProg">
+ <fonctions type="SaLDec">
+  <tete type="SaDecFonc" nom="main">
+   <corps type="SaInstBloc">
+    <val type="SaLInst">
+     <tete type="SaInstEcriture">
+      <arg type="SaExpInf">
+       <op1 type="SaExpInf">
+        <op1 type="SaExpInt" val="3"/>
+        <op2 type="SaExpInt" val="2"/>
+       </op1>
+       <op2 type="SaExpInt" val="1"/>
+      </arg>
+     </tete>
+    </val>
+   </corps>
+  </tete>
+ </fonctions>
+</programme>
diff --git a/test/sa-ref/mult1.sa b/test/sa-ref/mult1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d743995e203128b9c7ac7f1ae1e43eb238a870ea
--- /dev/null
+++ b/test/sa-ref/mult1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult 2 3)) null))) null))
diff --git a/test/sa-ref/mult2.sa b/test/sa-ref/mult2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..695c66c2c0f9fa633d86fa0a14fe2954b3bd7cde
--- /dev/null
+++ b/test/sa-ref/mult2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult 0 321)) null))) null))
diff --git a/test/sa-ref/mult3.sa b/test/sa-ref/mult3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..012c0a65b5e8ca62b4ea91523cdbd02a170ad0a8
--- /dev/null
+++ b/test/sa-ref/mult3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult (SaExpMult 3 3) 2)) null))) null))
diff --git a/test/sa-ref/not1.sa b/test/sa-ref/not1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..2f6a8a21ea11c6e636638bd1398ee4978885f550
--- /dev/null
+++ b/test/sa-ref/not1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot vrai)) null))) null))
diff --git a/test/sa-ref/not2.sa b/test/sa-ref/not2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d955f616d7ecbe0fa392fc51eb1fe26e30402347
--- /dev/null
+++ b/test/sa-ref/not2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot faux)) null))) null))
diff --git a/test/sa-ref/not3.sa b/test/sa-ref/not3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..1c04c2aaacf98dd09597852a88f0e8394b830890
--- /dev/null
+++ b/test/sa-ref/not3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot (SaExpNot faux))) null))) null))
diff --git a/test/sa-ref/or1.sa b/test/sa-ref/or1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..fb4fe3c00dfe07dcf1773af4a7470c9d21a55a7c
--- /dev/null
+++ b/test/sa-ref/or1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai vrai)) null))) null))
diff --git a/test/sa-ref/or2.sa b/test/sa-ref/or2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..02cc96cb9b932acfb9cfc5d2a127d2130b2876d2
--- /dev/null
+++ b/test/sa-ref/or2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai faux)) null))) null))
diff --git a/test/sa-ref/or3.sa b/test/sa-ref/or3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..a023eef9378764078df09ed090b0561b80f58f08
--- /dev/null
+++ b/test/sa-ref/or3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr faux vrai)) null))) null))
diff --git a/test/sa-ref/or4.sa b/test/sa-ref/or4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..1b585b46e7dfc3aa76f91667116f54dc0774880f
--- /dev/null
+++ b/test/sa-ref/or4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr faux faux)) null))) null))
diff --git a/test/sa-ref/or5.sa b/test/sa-ref/or5.sa
new file mode 100644
index 0000000000000000000000000000000000000000..c0030a3310d3cad83c4a36c9b7a4c1fdbe8bfc8a
--- /dev/null
+++ b/test/sa-ref/or5.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr (SaExpOr faux vrai) faux)) null))) null))
diff --git a/test/sa-ref/parenth1.sa b/test/sa-ref/parenth1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..fba5b651e63e6ae656279999ed27bd6d6fb7a523
--- /dev/null
+++ b/test/sa-ref/parenth1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) null))
diff --git a/test/sa-ref/parenth2.sa b/test/sa-ref/parenth2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..ddf44a1b134f76e0cc2079919ba5a91cccae5a4f
--- /dev/null
+++ b/test/sa-ref/parenth2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) null))
diff --git a/test/sa-ref/prio23-1.sa b/test/sa-ref/prio23-1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..4a35127cc33fb22e7adc34f3ff762bcd2d3e53b5
--- /dev/null
+++ b/test/sa-ref/prio23-1.sa
@@ -0,0 +1,18 @@
+<programme type="SaProg">
+ <fonctions type="SaLDec">
+  <tete type="SaDecFonc" nom="main">
+   <corps type="SaInstBloc">
+    <val type="SaLInst">
+     <tete type="SaInstEcriture">
+      <arg type="SaExpMult">
+       <op1 type="SaExpNot">
+        <op1 type="SaExpInt" val="0"/>
+       </op1>
+       <op2 type="SaExpInt" val="10"/>
+      </arg>
+     </tete>
+    </val>
+   </corps>
+  </tete>
+ </fonctions>
+</programme>
diff --git a/test/sa-ref/prio23-2.sa b/test/sa-ref/prio23-2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..31f61f2934fd97384fee5c55354ca5f8ff49df16
--- /dev/null
+++ b/test/sa-ref/prio23-2.sa
@@ -0,0 +1,18 @@
+<programme type="SaProg">
+ <fonctions type="SaLDec">
+  <tete type="SaDecFonc" nom="main">
+   <corps type="SaInstBloc">
+    <val type="SaLInst">
+     <tete type="SaInstEcriture">
+      <arg type="SaExpMult">
+       <op1 type="SaExpInt" val="3"/>
+       <op2 type="SaExpNot">
+        <op1 type="SaExpInt" val="10"/>
+       </op2>
+      </arg>
+     </tete>
+    </val>
+   </corps>
+  </tete>
+ </fonctions>
+</programme>
diff --git a/test/sa-ref/prio23-3.sa b/test/sa-ref/prio23-3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..b5c61582dadd231a632c7f5959f3b841268b8487
--- /dev/null
+++ b/test/sa-ref/prio23-3.sa
@@ -0,0 +1,18 @@
+<programme type="SaProg">
+ <fonctions type="SaLDec">
+  <tete type="SaDecFonc" nom="main">
+   <corps type="SaInstBloc">
+    <val type="SaLInst">
+     <tete type="SaInstEcriture">
+      <arg type="SaExpDiv">
+       <op1 type="SaExpNot">
+        <op1 type="SaExpInt" val="0"/>
+       </op1>
+       <op2 type="SaExpInt" val="1"/>
+      </arg>
+     </tete>
+    </val>
+   </corps>
+  </tete>
+ </fonctions>
+</programme>
diff --git a/test/sa-ref/prio23-4.sa b/test/sa-ref/prio23-4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..05c8c94a0597937ae2370581831178b15ed58e5e
--- /dev/null
+++ b/test/sa-ref/prio23-4.sa
@@ -0,0 +1,20 @@
+<programme type="SaProg">
+ <fonctions type="SaLDec">
+  <tete type="SaDecFonc" nom="main">
+   <corps type="SaInstBloc">
+    <val type="SaLInst">
+     <tete type="SaInstEcriture">
+      <arg type="SaExpDiv">
+       <op1 type="SaExpNot">
+        <op1 type="SaExpInt" val="1"/>
+       </op1>
+       <op2 type="SaExpNot">
+        <op1 type="SaExpInt" val="0"/>
+       </op2>
+      </arg>
+     </tete>
+    </val>
+   </corps>
+  </tete>
+ </fonctions>
+</programme>
diff --git a/test/sa-ref/prio34-1.sa b/test/sa-ref/prio34-1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..14486aef8ccd5e4c5a75eff8f4aae1bc40474167
--- /dev/null
+++ b/test/sa-ref/prio34-1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 2 (SaExpMult 3 4))) null))) null))
diff --git a/test/sa-ref/prio34-2.sa b/test/sa-ref/prio34-2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..4391e90f4e338a3bd64d9d2c7214087a863b19c7
--- /dev/null
+++ b/test/sa-ref/prio34-2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpMult 2 3) 4)) null))) null))
diff --git a/test/sa-ref/prio34-3.sa b/test/sa-ref/prio34-3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..93274cfeb293b7d012a1fc8e82ebfeb9f647080d
--- /dev/null
+++ b/test/sa-ref/prio34-3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpDiv 6 3) 72)) null))) null))
diff --git a/test/sa-ref/prio34-4.sa b/test/sa-ref/prio34-4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d0d61d75758c3e730253bc4786bcebf812237106
--- /dev/null
+++ b/test/sa-ref/prio34-4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 6 (SaExpDiv 20 10))) null))) null))
diff --git a/test/sa-ref/prio45-1.sa b/test/sa-ref/prio45-1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..74404e6426008aa4600f2446489038b42b8c76fd
--- /dev/null
+++ b/test/sa-ref/prio45-1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 2 (SaExpAdd 0 1))) null))) null))
diff --git a/test/sa-ref/prio45-2.sa b/test/sa-ref/prio45-2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..7225d278f316adacf6a60f4018e7e1871a23ee06
--- /dev/null
+++ b/test/sa-ref/prio45-2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual (SaExpAdd 1 234) 1)) null))) null))
diff --git a/test/sa-ref/prio45-3.sa b/test/sa-ref/prio45-3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f5fb6f090952e8bb78b17943efd6719bc6bd4c60
--- /dev/null
+++ b/test/sa-ref/prio45-3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 12 (SaExpAdd 11 100))) null))) null))
diff --git a/test/sa-ref/prio45-4.sa b/test/sa-ref/prio45-4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..4613fe18e913a3424895173542be907ec1e303eb
--- /dev/null
+++ b/test/sa-ref/prio45-4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf (SaExpSub 21 21) 1)) null))) null))
diff --git a/test/sa-ref/prio56-1.sa b/test/sa-ref/prio56-1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..2b698f43d0b112a4fd173daf76a5c4a2cef986da
--- /dev/null
+++ b/test/sa-ref/prio56-1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd (SaExpEqual 1 2) vrai)) null))) null))
diff --git a/test/sa-ref/prio56-2.sa b/test/sa-ref/prio56-2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..8a5cfa0e129c1fe29b2881a7025a0dd7e23e1209
--- /dev/null
+++ b/test/sa-ref/prio56-2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai (SaExpEqual faux vrai))) null))) null))
diff --git a/test/sa-ref/prio67-1.sa b/test/sa-ref/prio67-1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..3b05c3cbfeed1fc930dbd484cc6268f7cd78b154
--- /dev/null
+++ b/test/sa-ref/prio67-1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr (SaExpAnd faux vrai) vrai)) null))) null))
diff --git a/test/sa-ref/prio67-2.sa b/test/sa-ref/prio67-2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..0bd44357f4945c5deff0d7900b41dacf68d46a74
--- /dev/null
+++ b/test/sa-ref/prio67-2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai (SaExpAnd vrai faux))) null))) null))
diff --git a/test/sa-ref/rec1.sa b/test/sa-ref/rec1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..28199815d008b366f31e5308feab5036f97251e7
--- /dev/null
+++ b/test/sa-ref/rec1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc f entier (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstSi (SaExpEqual (SaExpVar (SaVarSimple a)) 1) (SaInstBloc (SaLInst (SaInstRetour 1) null)) (SaInstBloc (SaLInst (SaInstRetour (SaExpAdd 1 (SaExpAppel (SaAppel f (SaLExp (SaExpSub (SaExpVar (SaVarSimple a)) 1) null))))) null))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel f (SaLExp 100 null)))) null))) null)))
diff --git a/test/sa-ref/si1.sa b/test/sa-ref/si1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..86d331e258487460f275fdfb7ea022fe2ee6ba4a
--- /dev/null
+++ b/test/sa-ref/si1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) null) null))) null))
diff --git a/test/sa-ref/si2.sa b/test/sa-ref/si2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..609b54f653680a93dc8ff80ef34622d2d7bdf722
--- /dev/null
+++ b/test/sa-ref/si2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi faux (SaInstBloc (SaLInst (SaInstEcriture 1) null)) (SaInstBloc (SaLInst (SaInstEcriture 0) null))) null))) null))
diff --git a/test/sa-ref/si3.sa b/test/sa-ref/si3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..517789abfbdc1f91a95ce65329b8bac383c2d63d
--- /dev/null
+++ b/test/sa-ref/si3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) (SaInstBloc (SaLInst (SaInstEcriture faux) null))) (SaLInst (SaInstEcriture vrai) null)))) null))
diff --git a/test/sa-ref/si4.sa b/test/sa-ref/si4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..fef8d2a157e187470285db8eb9029aa1e76890da
--- /dev/null
+++ b/test/sa-ref/si4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi faux (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) (SaInstBloc (SaLInst (SaInstEcriture faux) null))) (SaLInst (SaInstEcriture vrai) null)))) null))
diff --git a/test/sa-ref/si5.sa b/test/sa-ref/si5.sa
new file mode 100644
index 0000000000000000000000000000000000000000..546ff2dcbcef78da6a0ed14ee9fbf923f5f41feb
--- /dev/null
+++ b/test/sa-ref/si5.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) null) null))) null) (SaLInst (SaInstEcriture vrai) null)))) null))
diff --git a/test/sa-ref/sub1.sa b/test/sa-ref/sub1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d03f2223ec693f881cfdadf38b0c1d9b171e74a7
--- /dev/null
+++ b/test/sa-ref/sub1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub 10 5)) null))) null))
diff --git a/test/sa-ref/sub2.sa b/test/sa-ref/sub2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..d1490e9d4c23c6c6043eb34250ac2f7ad249eb47
--- /dev/null
+++ b/test/sa-ref/sub2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub 7 20)) null))) null))
diff --git a/test/sa-ref/sub3.sa b/test/sa-ref/sub3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..9f30ba46267d3eb7ea35f5f616ded8ad5563d8d6
--- /dev/null
+++ b/test/sa-ref/sub3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpSub 2 1) 1)) null))) null))
diff --git a/test/sa-ref/tab1.sa b/test/sa-ref/tab1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..e6c5fb0dadd7d8dd900bc6fb6c7b3914b04fd3c3
--- /dev/null
+++ b/test/sa-ref/tab1.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecTab tab entier 3) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 0) (SaLInst (SaInstAffect (SaVarIndicee tab 1) 1) (SaLInst (SaInstAffect (SaVarIndicee tab 2) 2) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 0))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) null)))))))) null))
diff --git a/test/sa-ref/tab2.sa b/test/sa-ref/tab2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..077061594c81a94ba5d6d26143f4a1da2b85bd54
--- /dev/null
+++ b/test/sa-ref/tab2.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecTab tab entier 5) null) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple base entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple base) 2) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 0)) 34) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 1)) 74) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 2)) 16) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 3))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 4))) null))))))))) null))
diff --git a/test/sa-ref/tab3.sa b/test/sa-ref/tab3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..efb0fc06357b629498c28f34bd31e16e7259a2f3
--- /dev/null
+++ b/test/sa-ref/tab3.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecTab tab entier 5) null) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple base entier) (SaLDecVar (SaDecVarSimple offset entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple base) 2) (SaLInst (SaInstAffect (SaVarSimple offset) 0) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 34) (SaLInst (SaInstAffect (SaVarSimple offset) 1) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 74) (SaLInst (SaInstAffect (SaVarSimple offset) 2) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 16) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 3))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 4))) null)))))))))))) null))
diff --git a/test/sa-ref/tab4.sa b/test/sa-ref/tab4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..372b6bb81c892ea5709664d752777cf830542134
--- /dev/null
+++ b/test/sa-ref/tab4.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecTab tab entier 3) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 1) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarIndicee tab 0))) 12) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarIndicee tab 0)) 1)) 13) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 0))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) null)))))))) null))
diff --git a/test/sa-ref/tantque1.sa b/test/sa-ref/tantque1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..676e5f6862c70dd10f54d1945cb7bc19ed6bf83f
--- /dev/null
+++ b/test/sa-ref/tantque1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 10) (SaLInst (SaInstTantQue (SaExpInf 0 (SaExpVar (SaVarSimple a))) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstAffect (SaVarSimple a) (SaExpSub (SaExpVar (SaVarSimple a)) 1)) null)))) (SaLInst (SaInstEcriture 0) null))))) null))
diff --git a/test/sa-ref/tantque2.sa b/test/sa-ref/tantque2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..6482da5701bebb7de0557c34c4ac34a978f57056
--- /dev/null
+++ b/test/sa-ref/tantque2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple a)) 4) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple b) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple b)) 4) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) (SaLInst (SaInstAffect (SaVarSimple b) (SaExpAdd (SaExpVar (SaVarSimple b)) 1)) null))))) (SaLInst (SaInstAffect (SaVarSimple a) (SaExpAdd (SaExpVar (SaVarSimple a)) 1)) null))))) null)))) null))
diff --git a/test/sa-ref/tri.sa b/test/sa-ref/tri.sa
new file mode 100644
index 0000000000000000000000000000000000000000..69b37534ed3ec01824d281781e3add56422fe1d2
--- /dev/null
+++ b/test/sa-ref/tri.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecTab tab entier 10) null) (SaLDecFonc (SaDecFonc initialiser nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 8) (SaLInst (SaInstAffect (SaVarIndicee tab 1) 6) (SaLInst (SaInstAffect (SaVarIndicee tab 2) 9) (SaLInst (SaInstAffect (SaVarIndicee tab 3) 9) (SaLInst (SaInstAffect (SaVarIndicee tab 4) 4) (SaLInst (SaInstAffect (SaVarIndicee tab 5) 2) (SaLInst (SaInstAffect (SaVarIndicee tab 6) 3) (SaLInst (SaInstAffect (SaVarIndicee tab 7) 1) (SaLInst (SaInstAffect (SaVarIndicee tab 8) 4) (SaLInst (SaInstAffect (SaVarIndicee tab 9) 5) null)))))))))))) (SaLDecFonc (SaDecFonc afficher nul (SaLDecVar (SaDecVarSimple n entier) null) (SaLDecVar (SaDecVarSimple i entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple i) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple i)) (SaExpVar (SaVarSimple n))) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple i))))) (SaLInst (SaInstAffect (SaVarSimple i) (SaExpAdd (SaExpVar (SaVarSimple i)) 1)) null)))) (SaLInst (SaInstEcriture 0) null))))) (SaLDecFonc (SaDecFonc echanger nul (SaLDecVar (SaDecVarSimple i entier) (SaLDecVar (SaDecVarSimple j entier) null)) (SaLDecVar (SaDecVarSimple temp entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple temp) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple j))))) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarSimple j))) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple i))))) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarSimple i))) (SaExpVar (SaVarSimple temp))) null))))) (SaLDecFonc (SaDecFonc trier nul (SaLDecVar (SaDecVarSimple n entier) null) (SaLDecVar (SaDecVarSimple echange entier) (SaLDecVar (SaDecVarSimple j entier) (SaLDecVar (SaDecVarSimple m entier) null))) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple m) (SaExpVar (SaVarSimple n))) (SaLInst (SaInstAffect (SaVarSimple echange) 1) (SaLInst (SaInstTantQue (SaExpEqual (SaExpVar (SaVarSimple echange)) 1) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple echange) 0) (SaLInst (SaInstAffect (SaVarSimple j) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple j)) (SaExpSub (SaExpVar (SaVarSimple m)) 1)) (SaInstBloc (SaLInst (SaInstSi (SaExpInf (SaExpVar (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple j)) 1))) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple j))))) (SaInstBloc (SaLInst (SaAppel echanger (SaLExp (SaExpVar (SaVarSimple j)) (SaLExp (SaExpAdd (SaExpVar (SaVarSimple j)) 1) null))) (SaLInst (SaInstAffect (SaVarSimple echange) 1) null))) null) (SaLInst (SaInstAffect (SaVarSimple j) (SaExpAdd (SaExpVar (SaVarSimple j)) 1)) null)))) (SaLInst (SaInstAffect (SaVarSimple m) (SaExpSub (SaExpVar (SaVarSimple m)) 1)) null)))))) null))))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel initialiser null) (SaLInst (SaAppel afficher (SaLExp 10 null)) (SaLInst (SaAppel trier (SaLExp 10 null)) (SaLInst (SaAppel afficher (SaLExp 10 null)) null)))))) null))))))
diff --git a/test/sa-ref/varglob1.sa b/test/sa-ref/varglob1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f0e56eb12aa619553375b4ff661d6dd25c0fad12
--- /dev/null
+++ b/test/sa-ref/varglob1.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple variable entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 6834) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple variable))) null)))) null))
diff --git a/test/sa-ref/varglob2.sa b/test/sa-ref/varglob2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..5f173ad9f00cd74d6334a64ab1e11d622a5d6372
--- /dev/null
+++ b/test/sa-ref/varglob2.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple variable entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 10) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple variable)) 50)) null)))) null))
diff --git a/test/sa-ref/varglob3.sa b/test/sa-ref/varglob3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..846697305f7abcfa1e4e123c0f2d596b30d3d35d
--- /dev/null
+++ b/test/sa-ref/varglob3.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 34) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var2))) null)))))) null))
diff --git a/test/sa-ref/varglob4.sa b/test/sa-ref/varglob4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..4d47fed3a34fdc6be3f3fa2fc5db6284be2b8f5a
--- /dev/null
+++ b/test/sa-ref/varglob4.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 34) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple var1)) (SaExpVar (SaVarSimple var2)))) null))))) null))
diff --git a/test/sa-ref/varloc1.sa b/test/sa-ref/varloc1.sa
new file mode 100644
index 0000000000000000000000000000000000000000..f73881af093a60fa354646b006976fa551c00242
--- /dev/null
+++ b/test/sa-ref/varloc1.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple variable entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 6834) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple variable))) null)))) null))
diff --git a/test/sa-ref/varloc2.sa b/test/sa-ref/varloc2.sa
new file mode 100644
index 0000000000000000000000000000000000000000..35a55ff8724bace3df9f3392254ba86b85616997
--- /dev/null
+++ b/test/sa-ref/varloc2.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple variable entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 10) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple variable)) 50)) null)))) null))
diff --git a/test/sa-ref/varloc3.sa b/test/sa-ref/varloc3.sa
new file mode 100644
index 0000000000000000000000000000000000000000..3c7878c76ccf675dcad3f1c5bc6202b4575f03a3
--- /dev/null
+++ b/test/sa-ref/varloc3.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 30) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var2))) null)))))) null))
diff --git a/test/sa-ref/varloc4.sa b/test/sa-ref/varloc4.sa
new file mode 100644
index 0000000000000000000000000000000000000000..0578507dd5968c5fe82fc524a5a407bb50feea7e
--- /dev/null
+++ b/test/sa-ref/varloc4.sa
@@ -0,0 +1 @@
+(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 30) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple var1)) (SaExpVar (SaVarSimple var2)))) null))))) null))
diff --git a/test/sa-ref/varloc5.sa b/test/sa-ref/varloc5.sa
new file mode 100644
index 0000000000000000000000000000000000000000..dbeb0be8a23167bb3b1599bdbb43d9088ee6cb55
--- /dev/null
+++ b/test/sa-ref/varloc5.sa
@@ -0,0 +1 @@
+(SaProg (SaLDecVar (SaDecVarSimple var1 entier) null) (SaLDecFonc (SaDecFonc f nul null (SaLDecVar (SaDecVarSimple var1 entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 20) (SaLInst (SaAppel f null) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) null))))) null)))
diff --git a/test/sc-ref/add1.sc b/test/sc-ref/add1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..5ba6a480a29890b70b93fd840dc04e14d361af1b
--- /dev/null
+++ b/test/sc-ref/add1.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <APlusExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </APlusExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/add2.sc b/test/sc-ref/add2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..5447ac910caee351436e37efef64078847ac243e
--- /dev/null
+++ b/test/sc-ref/add2.sc
@@ -0,0 +1,52 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <APlusExp3>
+            <APlusExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </APlusExp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </APlusExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/affect1.sc b/test/sc-ref/affect1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..919a43405a186954fd65d20f556024a803342d62
--- /dev/null
+++ b/test/sc-ref/affect1.sc
@@ -0,0 +1,66 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/affect2.sc b/test/sc-ref/affect2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..55761e9d89bd27bd62295bbd738b4e7d185f96a2
--- /dev/null
+++ b/test/sc-ref/affect2.sc
@@ -0,0 +1,66 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/affect3.sc b/test/sc-ref/affect3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6046f37de9328f1ce4cd85e6f286d61867f772df
--- /dev/null
+++ b/test/sc-ref/affect3.sc
@@ -0,0 +1,106 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <ADecvarinstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AOptdecvar>
+      <ADecvarListedecvar>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvar>
+     </AOptdecvar>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <ARecursifListeexp>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+           <AFinalListeexpbis>
+           </AFinalListeexpbis>
+          </ARecursifListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </ADecvarinstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/and1.sc b/test/sc-ref/and1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569
--- /dev/null
+++ b/test/sc-ref/and1.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/and2.sc b/test/sc-ref/and2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569
--- /dev/null
+++ b/test/sc-ref/and2.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/and3.sc b/test/sc-ref/and3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569
--- /dev/null
+++ b/test/sc-ref/and3.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/and4.sc b/test/sc-ref/and4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569
--- /dev/null
+++ b/test/sc-ref/and4.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/and5.sc b/test/sc-ref/and5.sc
new file mode 100644
index 0000000000000000000000000000000000000000..22cd18f28a5a65306ce88711fd082058a2e7bd2c
--- /dev/null
+++ b/test/sc-ref/and5.sc
@@ -0,0 +1,60 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AEtExp1>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AEtExp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel-param1.sc b/test/sc-ref/appel-param1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..5f242e2f863ea7b72091f37d523f25492e6059ad
--- /dev/null
+++ b/test/sc-ref/appel-param1.sc
@@ -0,0 +1,78 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AVarExp6>
+               <AVarsimpleVar>
+               </AVarsimpleVar>
+              </AVarExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <ARecursifListeexp>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+           <AFinalListeexpbis>
+           </AFinalListeexpbis>
+          </ARecursifListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel-param2.sc b/test/sc-ref/appel-param2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..c683b17d10544150d947a9b96eb99c8cabcc829c
--- /dev/null
+++ b/test/sc-ref/appel-param2.sc
@@ -0,0 +1,120 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AVarExp6>
+               <AVarsimpleVar>
+               </AVarsimpleVar>
+              </AVarExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <ARecursifListeexp>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+           <ARecursifListeexpbis>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+            <AFinalListeexpbis>
+            </AFinalListeexpbis>
+           </ARecursifListeexpbis>
+          </ARecursifListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel-param3.sc b/test/sc-ref/appel-param3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6aab83be2aa9a3f817025074066e1eb798250afe
--- /dev/null
+++ b/test/sc-ref/appel-param3.sc
@@ -0,0 +1,246 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarldecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+       <ADecvarldecvarListedecvarbis>
+        <ADecvarentierDecvar>
+        </ADecvarentierDecvar>
+        <ADecvarldecvarListedecvarbis>
+         <ADecvarentierDecvar>
+         </ADecvarentierDecvar>
+         <ADecvarListedecvarbis>
+          <ADecvarentierDecvar>
+          </ADecvarentierDecvar>
+         </ADecvarListedecvarbis>
+        </ADecvarldecvarListedecvarbis>
+       </ADecvarldecvarListedecvarbis>
+      </ADecvarldecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AVarExp6>
+               <AVarsimpleVar>
+               </AVarsimpleVar>
+              </AVarExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVarsimpleVar>
+                   </AVarsimpleVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstfinalListeinst>
+          </ALinstfinalListeinst>
+         </ALinstrecListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <ARecursifListeexp>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+           <ARecursifListeexpbis>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+            <ARecursifListeexpbis>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+             <ARecursifListeexpbis>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AExp3Exp2>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <ANombreExp6>
+                    </ANombreExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                </AExp3Exp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+              <ARecursifListeexpbis>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+               <AFinalListeexpbis>
+               </AFinalListeexpbis>
+              </ARecursifListeexpbis>
+             </ARecursifListeexpbis>
+            </ARecursifListeexpbis>
+           </ARecursifListeexpbis>
+          </ARecursifListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel-retour1.sc b/test/sc-ref/appel-retour1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..64940ad64c06078e8060d5e3f12eeabb325c4b2c
--- /dev/null
+++ b/test/sc-ref/appel-retour1.sc
@@ -0,0 +1,106 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrretourInstr>
+       <AInstrretour>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AVarExp6>
+                      <AVarsimpleVar>
+                      </AVarsimpleVar>
+                     </AVarExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrretour>
+      </AInstrretourInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AAppelfctExp6>
+                <AAppelfct>
+                 <ARecursifListeexp>
+                  <AExp1Exp>
+                   <AExp2Exp1>
+                    <AExp3Exp2>
+                     <AExp4Exp3>
+                      <AExp5Exp4>
+                       <AExp6Exp5>
+                        <ANombreExp6>
+                        </ANombreExp6>
+                       </AExp6Exp5>
+                      </AExp5Exp4>
+                     </AExp4Exp3>
+                    </AExp3Exp2>
+                   </AExp2Exp1>
+                  </AExp1Exp>
+                  <AFinalListeexpbis>
+                  </AFinalListeexpbis>
+                 </ARecursifListeexp>
+                </AAppelfct>
+               </AAppelfctExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel1.sc b/test/sc-ref/appel1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..146cd4a3e8bb125dd6ddb7debe5c428c78058ffb
--- /dev/null
+++ b/test/sc-ref/appel1.sc
@@ -0,0 +1,56 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <AFinalListeexp>
+          </AFinalListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel2.sc b/test/sc-ref/appel2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..b1e1d36df31c9c31c04d038b448eacaebef1c4fe
--- /dev/null
+++ b/test/sc-ref/appel2.sc
@@ -0,0 +1,96 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstrecListeinst>
+        <AInstrappelInstr>
+         <AInstrappel>
+          <AAppelfct>
+           <AFinalListeexp>
+           </AFinalListeexp>
+          </AAppelfct>
+         </AInstrappel>
+        </AInstrappelInstr>
+        <ALinstfinalListeinst>
+        </ALinstfinalListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncrecListedecfonc>
+     <AInstrDecfonc>
+      <ASansparamListeparam>
+      </ASansparamListeparam>
+      <AInstrbloc>
+       <ALinstrecListeinst>
+        <AInstrappelInstr>
+         <AInstrappel>
+          <AAppelfct>
+           <AFinalListeexp>
+           </AFinalListeexp>
+          </AAppelfct>
+         </AInstrappel>
+        </AInstrappelInstr>
+        <ALinstfinalListeinst>
+        </ALinstfinalListeinst>
+       </ALinstrecListeinst>
+      </AInstrbloc>
+     </AInstrDecfonc>
+     <ALdecfoncfinalListedecfonc>
+     </ALdecfoncfinalListedecfonc>
+    </ALdecfoncrecListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/appel3.sc b/test/sc-ref/appel3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..1e1737c75cc1ebcbe652ffc91389166348e2e687
--- /dev/null
+++ b/test/sc-ref/appel3.sc
@@ -0,0 +1,96 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncrecListedecfonc>
+     <AInstrDecfonc>
+      <ASansparamListeparam>
+      </ASansparamListeparam>
+      <AInstrbloc>
+       <ALinstrecListeinst>
+        <AInstrappelInstr>
+         <AInstrappel>
+          <AAppelfct>
+           <AFinalListeexp>
+           </AFinalListeexp>
+          </AAppelfct>
+         </AInstrappel>
+        </AInstrappelInstr>
+        <ALinstrecListeinst>
+         <AInstrappelInstr>
+          <AInstrappel>
+           <AAppelfct>
+            <AFinalListeexp>
+            </AFinalListeexp>
+           </AAppelfct>
+          </AInstrappel>
+         </AInstrappelInstr>
+         <ALinstfinalListeinst>
+         </ALinstfinalListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </AInstrbloc>
+     </AInstrDecfonc>
+     <ALdecfoncfinalListedecfonc>
+     </ALdecfoncfinalListedecfonc>
+    </ALdecfoncrecListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/div1.sc b/test/sc-ref/div1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5
--- /dev/null
+++ b/test/sc-ref/div1.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/div2.sc b/test/sc-ref/div2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5
--- /dev/null
+++ b/test/sc-ref/div2.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/div3.sc b/test/sc-ref/div3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..2fe7922a5a5bf64db5d617ac42b1c2b5f4f91ff0
--- /dev/null
+++ b/test/sc-ref/div3.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <ADiviseExp4>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ADiviseExp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/div4.sc b/test/sc-ref/div4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5
--- /dev/null
+++ b/test/sc-ref/div4.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/ecrire1.sc b/test/sc-ref/ecrire1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..03c62d11fbc895298722782757f614c1e2be261e
--- /dev/null
+++ b/test/sc-ref/ecrire1.sc
@@ -0,0 +1,36 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/ecrire2.sc b/test/sc-ref/ecrire2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..03c62d11fbc895298722782757f614c1e2be261e
--- /dev/null
+++ b/test/sc-ref/ecrire2.sc
@@ -0,0 +1,36 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/egal1.sc b/test/sc-ref/egal1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..19ab92d9e23815660d1b80ac63b3ed29dfcbf26c
--- /dev/null
+++ b/test/sc-ref/egal1.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AEgalExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AEgalExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/egal2.sc b/test/sc-ref/egal2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..19ab92d9e23815660d1b80ac63b3ed29dfcbf26c
--- /dev/null
+++ b/test/sc-ref/egal2.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AEgalExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AEgalExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/egal3.sc b/test/sc-ref/egal3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..4c55fe83c04086b5963af1a73288b418bd319443
--- /dev/null
+++ b/test/sc-ref/egal3.sc
@@ -0,0 +1,56 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AEgalExp2>
+           <AEgalExp2>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AEgalExp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AEgalExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/err1.sc b/test/sc-ref/err1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..2836d73cd31a01f89feadfeacacd8761e519c15c
--- /dev/null
+++ b/test/sc-ref/err1.sc
@@ -0,0 +1,38 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AVarExp6>
+               <AVarsimpleVar>
+               </AVarsimpleVar>
+              </AVarExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/err2.sc b/test/sc-ref/err2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..2eb2ef9af775dbac73197258ebba340db3fd9e19
--- /dev/null
+++ b/test/sc-ref/err2.sc
@@ -0,0 +1,26 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrappelInstr>
+       <AInstrappel>
+        <AAppelfct>
+         <AFinalListeexp>
+         </AFinalListeexp>
+        </AAppelfct>
+       </AInstrappel>
+      </AInstrappelInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/err3.sc b/test/sc-ref/err3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..b159de5537afb74d191f12465258ada67750ccd8
--- /dev/null
+++ b/test/sc-ref/err3.sc
@@ -0,0 +1,40 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AAvecparamListeparam>
+    <AInstrbloc>
+     <ALinstfinalListeinst>
+     </ALinstfinalListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <AFinalListeexp>
+          </AFinalListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/err4.sc b/test/sc-ref/err4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..ae87ec482b1d627a4cd26beb413c4313a161140a
--- /dev/null
+++ b/test/sc-ref/err4.sc
@@ -0,0 +1,62 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <AAvecparamListeparam>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AAvecparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstfinalListeinst>
+     </ALinstfinalListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstrappelInstr>
+        <AInstrappel>
+         <AAppelfct>
+          <ARecursifListeexp>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+           <AFinalListeexpbis>
+           </AFinalListeexpbis>
+          </ARecursifListeexp>
+         </AAppelfct>
+        </AInstrappel>
+       </AInstrappelInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/err5.sc b/test/sc-ref/err5.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6e983507c48e7924c38675666aa98b28a33b2144
--- /dev/null
+++ b/test/sc-ref/err5.sc
@@ -0,0 +1,78 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <ADecvarinstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AOptdecvar>
+      <ADecvarListedecvar>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvar>
+     </AOptdecvar>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AAppelfctExp6>
+                <AAppelfct>
+                 <AFinalListeexp>
+                 </AFinalListeexp>
+                </AAppelfct>
+               </AAppelfctExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </ADecvarinstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/fibo.sc b/test/sc-ref/fibo.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f6f4346cede20ca40faf792af1e7e281253f03d4
--- /dev/null
+++ b/test/sc-ref/fibo.sc
@@ -0,0 +1,248 @@
+<Start>
+ <AProgramme>
+  <AVideListedecvar>
+   <AEpsilon>
+   </AEpsilon>
+  </AVideListedecvar>
+  <ARecursifListedecfonc>
+   <ADecfonc>
+    <AEntierOpttype>
+    </AEntierOpttype>
+    <APremierListedecvar>
+     <AScalaireDecvar>
+      <AEntierType>
+      </AEntierType>
+     </AScalaireDecvar>
+     <AFinalListedecvarbis>
+      <AEpsilon>
+      </AEpsilon>
+     </AFinalListedecvarbis>
+    </APremierListedecvar>
+    <AVideListedecvar>
+     <AEpsilon>
+     </AEpsilon>
+    </AVideListedecvar>
+    <AInstrbloc>
+     <ARecursifListeinst>
+      <ASinonInstr>
+       <AExp1Exp>
+        <AExp2Exp1>
+         <AInfExp2>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AVarExp6>
+               <ASimpleVar>
+               </ASimpleVar>
+              </AVarExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+          <AExp4Exp3>
+           <AExp5Exp4>
+            <AExp6Exp5>
+             <ANombreExp6>
+             </ANombreExp6>
+            </AExp6Exp5>
+           </AExp5Exp4>
+          </AExp4Exp3>
+         </AInfExp2>
+        </AExp2Exp1>
+       </AExp1Exp>
+       <AInstrbloc>
+        <ARecursifListeinst>
+         <ARetourInstr>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </ARetourInstr>
+         <AFinalListeinst>
+          <AEpsilon>
+          </AEpsilon>
+         </AFinalListeinst>
+        </ARecursifListeinst>
+       </AInstrbloc>
+       <AInstrbloc>
+        <ARecursifListeinst>
+         <ARetourInstr>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <APlusExp3>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AAppelfctExp6>
+                  <AAppelfct>
+                   <APremierListeexp>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AMoinsExp3>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <AVarExp6>
+                            <ASimpleVar>
+                            </ASimpleVar>
+                           </AVarExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AMoinsExp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                    <AFinalListeexpbis>
+                     <AEpsilon>
+                     </AEpsilon>
+                    </AFinalListeexpbis>
+                   </APremierListeexp>
+                  </AAppelfct>
+                 </AAppelfctExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AAppelfctExp6>
+                 <AAppelfct>
+                  <APremierListeexp>
+                   <AExp1Exp>
+                    <AExp2Exp1>
+                     <AExp3Exp2>
+                      <AMoinsExp3>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <AVarExp6>
+                           <ASimpleVar>
+                           </ASimpleVar>
+                          </AVarExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                       <AExp5Exp4>
+                        <AExp6Exp5>
+                         <ANombreExp6>
+                         </ANombreExp6>
+                        </AExp6Exp5>
+                       </AExp5Exp4>
+                      </AMoinsExp3>
+                     </AExp3Exp2>
+                    </AExp2Exp1>
+                   </AExp1Exp>
+                   <AFinalListeexpbis>
+                    <AEpsilon>
+                    </AEpsilon>
+                   </AFinalListeexpbis>
+                  </APremierListeexp>
+                 </AAppelfct>
+                </AAppelfctExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </APlusExp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </ARetourInstr>
+         <AFinalListeinst>
+          <AEpsilon>
+          </AEpsilon>
+         </AFinalListeinst>
+        </ARecursifListeinst>
+       </AInstrbloc>
+      </ASinonInstr>
+      <AFinalListeinst>
+       <AEpsilon>
+       </AEpsilon>
+      </AFinalListeinst>
+     </ARecursifListeinst>
+    </AInstrbloc>
+   </ADecfonc>
+   <ARecursifListedecfonc>
+    <ADecfonc>
+     <AVideOpttype>
+     </AVideOpttype>
+     <AVideListedecvar>
+      <AEpsilon>
+      </AEpsilon>
+     </AVideListedecvar>
+     <AVideListedecvar>
+      <AEpsilon>
+      </AEpsilon>
+     </AVideListedecvar>
+     <AInstrbloc>
+      <ARecursifListeinst>
+       <AEcritureInstr>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AAppelfctExp6>
+               <AAppelfct>
+                <APremierListeexp>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <ANombreExp6>
+                       </ANombreExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                 <AFinalListeexpbis>
+                  <AEpsilon>
+                  </AEpsilon>
+                 </AFinalListeexpbis>
+                </APremierListeexp>
+               </AAppelfct>
+              </AAppelfctExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AEcritureInstr>
+       <AFinalListeinst>
+        <AEpsilon>
+        </AEpsilon>
+       </AFinalListeinst>
+      </ARecursifListeinst>
+     </AInstrbloc>
+    </ADecfonc>
+    <AFinalListedecfonc>
+     <AEpsilon>
+     </AEpsilon>
+    </AFinalListedecfonc>
+   </ARecursifListedecfonc>
+  </ARecursifListedecfonc>
+ </AProgramme>
+</Start>
diff --git a/test/sc-ref/inf1.sc b/test/sc-ref/inf1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9
--- /dev/null
+++ b/test/sc-ref/inf1.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/inf2.sc b/test/sc-ref/inf2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9
--- /dev/null
+++ b/test/sc-ref/inf2.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/inf3.sc b/test/sc-ref/inf3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9
--- /dev/null
+++ b/test/sc-ref/inf3.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/inf4.sc b/test/sc-ref/inf4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..4804d6f1e76514fd68ff0d48bcdbfb4b555a3dd1
--- /dev/null
+++ b/test/sc-ref/inf4.sc
@@ -0,0 +1,56 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AInfExp2>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AInfExp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/modulo1.sc b/test/sc-ref/modulo1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..470dfbf46112fa0b40c8a00ade74e3ec3cdc6d5b
--- /dev/null
+++ b/test/sc-ref/modulo1.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AModuloExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AModuloExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/mult1.sc b/test/sc-ref/mult1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..43b5a18c6b58557388531f691192174d40dd2737
--- /dev/null
+++ b/test/sc-ref/mult1.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AFoisExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AFoisExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/mult2.sc b/test/sc-ref/mult2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..43b5a18c6b58557388531f691192174d40dd2737
--- /dev/null
+++ b/test/sc-ref/mult2.sc
@@ -0,0 +1,42 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AFoisExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AFoisExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/mult3.sc b/test/sc-ref/mult3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..ed24546b2b752eae7491aba8b1994dad2cb79252
--- /dev/null
+++ b/test/sc-ref/mult3.sc
@@ -0,0 +1,48 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AFoisExp4>
+             <AFoisExp4>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AFoisExp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AFoisExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/not1.sc b/test/sc-ref/not1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f1def7ef8ee6936812a31a3a870abac25cfa32b9
--- /dev/null
+++ b/test/sc-ref/not1.sc
@@ -0,0 +1,38 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <ANonExp5>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ANonExp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/not2.sc b/test/sc-ref/not2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f1def7ef8ee6936812a31a3a870abac25cfa32b9
--- /dev/null
+++ b/test/sc-ref/not2.sc
@@ -0,0 +1,38 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <ANonExp5>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ANonExp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/not3.sc b/test/sc-ref/not3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..c72880b10dddc5a590103842dff5826701a78eb0
--- /dev/null
+++ b/test/sc-ref/not3.sc
@@ -0,0 +1,40 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <ANonExp5>
+              <ANonExp5>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </ANonExp5>
+             </ANonExp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/or1.sc b/test/sc-ref/or1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430
--- /dev/null
+++ b/test/sc-ref/or1.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/or2.sc b/test/sc-ref/or2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430
--- /dev/null
+++ b/test/sc-ref/or2.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/or3.sc b/test/sc-ref/or3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430
--- /dev/null
+++ b/test/sc-ref/or3.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/or4.sc b/test/sc-ref/or4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430
--- /dev/null
+++ b/test/sc-ref/or4.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/or5.sc b/test/sc-ref/or5.sc
new file mode 100644
index 0000000000000000000000000000000000000000..954b836e8137a328b1a7b23111e9ad442dcaec05
--- /dev/null
+++ b/test/sc-ref/or5.sc
@@ -0,0 +1,64 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AOuExp>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AOuExp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/parenth1.sc b/test/sc-ref/parenth1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..6e5d8d2385ff1a239c88095d7942a273f0c7214f
--- /dev/null
+++ b/test/sc-ref/parenth1.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/parenth2.sc b/test/sc-ref/parenth2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..eff72be83c53c7c8dc2f6a93b700a0ee8a0f543f
--- /dev/null
+++ b/test/sc-ref/parenth2.sc
@@ -0,0 +1,64 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AParenthesesExp6>
+                      <AExp1Exp>
+                       <AExp2Exp1>
+                        <AExp3Exp2>
+                         <AExp4Exp3>
+                          <AExp5Exp4>
+                           <AExp6Exp5>
+                            <ANombreExp6>
+                            </ANombreExp6>
+                           </AExp6Exp5>
+                          </AExp5Exp4>
+                         </AExp4Exp3>
+                        </AExp3Exp2>
+                       </AExp2Exp1>
+                      </AExp1Exp>
+                     </AParenthesesExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio23-1.sc b/test/sc-ref/prio23-1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..d19611ddd81e953c342eb7e980427db4239f7944
--- /dev/null
+++ b/test/sc-ref/prio23-1.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AFoisExp4>
+             <AExp5Exp4>
+              <ANonExp5>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </ANonExp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AFoisExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio23-2.sc b/test/sc-ref/prio23-2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..41731ecc7c25dcffa320e6d00b4461d4412f074c
--- /dev/null
+++ b/test/sc-ref/prio23-2.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AFoisExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <ANonExp5>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ANonExp5>
+            </AFoisExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio23-3.sc b/test/sc-ref/prio23-3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..fc90db428a8474c7f36b22e87250379dfe7118cf
--- /dev/null
+++ b/test/sc-ref/prio23-3.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <ANonExp5>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </ANonExp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio23-4.sc b/test/sc-ref/prio23-4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..9e096755df901a550803b9acb493ea0033a18860
--- /dev/null
+++ b/test/sc-ref/prio23-4.sc
@@ -0,0 +1,46 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <ANonExp5>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </ANonExp5>
+             </AExp5Exp4>
+             <ANonExp5>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ANonExp5>
+            </ADiviseExp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio34-1.sc b/test/sc-ref/prio34-1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..b91f1fb0686012c5df322c3fd619f4a9e3482f92
--- /dev/null
+++ b/test/sc-ref/prio34-1.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <APlusExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AFoisExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AFoisExp4>
+           </APlusExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio34-2.sc b/test/sc-ref/prio34-2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..83731e75a1fa8196b2c93895fffe83fe17202dc3
--- /dev/null
+++ b/test/sc-ref/prio34-2.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AMoinsExp3>
+            <AExp4Exp3>
+             <AFoisExp4>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AFoisExp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AMoinsExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio34-3.sc b/test/sc-ref/prio34-3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..c2ea56d38f6f86cc6dc0e15e2cb823dc0bd38b6d
--- /dev/null
+++ b/test/sc-ref/prio34-3.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AMoinsExp3>
+            <AExp4Exp3>
+             <ADiviseExp4>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </ADiviseExp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AMoinsExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio34-4.sc b/test/sc-ref/prio34-4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..3e2860a9dfe4713f1379c2d3455eb919fc7bde62
--- /dev/null
+++ b/test/sc-ref/prio34-4.sc
@@ -0,0 +1,50 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <APlusExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <ADiviseExp4>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </ADiviseExp4>
+           </APlusExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio45-1.sc b/test/sc-ref/prio45-1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..76d3b8d04e93b006e4d7b57afa96c3fe6d8dc18b
--- /dev/null
+++ b/test/sc-ref/prio45-1.sc
@@ -0,0 +1,54 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AEgalExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <APlusExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </APlusExp3>
+          </AEgalExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio45-2.sc b/test/sc-ref/prio45-2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..721d838f8dc47d395bcc1e3af3f212ab712d7856
--- /dev/null
+++ b/test/sc-ref/prio45-2.sc
@@ -0,0 +1,54 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AEgalExp2>
+           <AExp3Exp2>
+            <APlusExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </APlusExp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AEgalExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio45-3.sc b/test/sc-ref/prio45-3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..5777f26f63bed1dc8246bb031ae61565acbf6c06
--- /dev/null
+++ b/test/sc-ref/prio45-3.sc
@@ -0,0 +1,54 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <APlusExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </APlusExp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio45-4.sc b/test/sc-ref/prio45-4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..02dd9dd82feb9edfe2df2c8626e2b9a359efaafa
--- /dev/null
+++ b/test/sc-ref/prio45-4.sc
@@ -0,0 +1,54 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AInfExp2>
+           <AExp3Exp2>
+            <AMoinsExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AMoinsExp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AInfExp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio56-1.sc b/test/sc-ref/prio56-1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..a59126e8a317066ca0eb78f6694f3e20f7f0bc06
--- /dev/null
+++ b/test/sc-ref/prio56-1.sc
@@ -0,0 +1,58 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AEgalExp2>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AEgalExp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio56-2.sc b/test/sc-ref/prio56-2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..480375b5af5cb27d25b1de0718aa8f516c15e2ad
--- /dev/null
+++ b/test/sc-ref/prio56-2.sc
@@ -0,0 +1,58 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AEgalExp2>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AEgalExp2>
+         </AEtExp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio67-1.sc b/test/sc-ref/prio67-1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f096c7c8cdfb7a99c40bc24c050c3594d4eca0a9
--- /dev/null
+++ b/test/sc-ref/prio67-1.sc
@@ -0,0 +1,62 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AEtExp1>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AEtExp1>
+         </AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/prio67-2.sc b/test/sc-ref/prio67-2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..9bb0df80e9aa6e023936d46257ce357c02fbcc7c
--- /dev/null
+++ b/test/sc-ref/prio67-2.sc
@@ -0,0 +1,62 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AOuExp>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AEtExp1>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AEtExp1>
+        </AOuExp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/rec1.sc b/test/sc-ref/rec1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..1f75e3997f0fd594e3727c7c662f9f0cb1eb3da7
--- /dev/null
+++ b/test/sc-ref/rec1.sc
@@ -0,0 +1,258 @@
+<Start>
+ <AProgramme>
+  <AVideListedecvar>
+   <AEpsilon>
+   </AEpsilon>
+  </AVideListedecvar>
+  <ARecursifListedecfonc>
+   <ADecfonc>
+    <AEntierOpttype>
+    </AEntierOpttype>
+    <APremierListedecvar>
+     <AScalaireDecvar>
+      <AEntierType>
+      </AEntierType>
+     </AScalaireDecvar>
+     <AFinalListedecvarbis>
+      <AEpsilon>
+      </AEpsilon>
+     </AFinalListedecvarbis>
+    </APremierListedecvar>
+    <AVideListedecvar>
+     <AEpsilon>
+     </AEpsilon>
+    </AVideListedecvar>
+    <AInstrbloc>
+     <ARecursifListeinst>
+      <ASinonInstr>
+       <AExp1Exp>
+        <AExp2Exp1>
+         <AExp3Exp2>
+          <AExp4Exp3>
+           <AExp5Exp4>
+            <AExp6Exp5>
+             <AParenthesesExp6>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AEgalExp2>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AVarExp6>
+                      <ASimpleVar>
+                      </ASimpleVar>
+                     </AVarExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <ANombreExp6>
+                    </ANombreExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                </AEgalExp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+             </AParenthesesExp6>
+            </AExp6Exp5>
+           </AExp5Exp4>
+          </AExp4Exp3>
+         </AExp3Exp2>
+        </AExp2Exp1>
+       </AExp1Exp>
+       <AInstrbloc>
+        <ARecursifListeinst>
+         <ARetourInstr>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AParenthesesExp6>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <ANombreExp6>
+                       </ANombreExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                </AParenthesesExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </ARetourInstr>
+         <AFinalListeinst>
+          <AEpsilon>
+          </AEpsilon>
+         </AFinalListeinst>
+        </ARecursifListeinst>
+       </AInstrbloc>
+       <AInstrbloc>
+        <ARecursifListeinst>
+         <ARetourInstr>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AParenthesesExp6>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <APlusExp3>
+                     <AExp4Exp3>
+                      <AExp5Exp4>
+                       <AExp6Exp5>
+                        <ANombreExp6>
+                        </ANombreExp6>
+                       </AExp6Exp5>
+                      </AExp5Exp4>
+                     </AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <AAppelfctExp6>
+                        <AAppelfct>
+                         <APremierListeexp>
+                          <AExp1Exp>
+                           <AExp2Exp1>
+                            <AExp3Exp2>
+                             <AMoinsExp3>
+                              <AExp4Exp3>
+                               <AExp5Exp4>
+                                <AExp6Exp5>
+                                 <AVarExp6>
+                                  <ASimpleVar>
+                                  </ASimpleVar>
+                                 </AVarExp6>
+                                </AExp6Exp5>
+                               </AExp5Exp4>
+                              </AExp4Exp3>
+                              <AExp5Exp4>
+                               <AExp6Exp5>
+                                <ANombreExp6>
+                                </ANombreExp6>
+                               </AExp6Exp5>
+                              </AExp5Exp4>
+                             </AMoinsExp3>
+                            </AExp3Exp2>
+                           </AExp2Exp1>
+                          </AExp1Exp>
+                          <AFinalListeexpbis>
+                           <AEpsilon>
+                           </AEpsilon>
+                          </AFinalListeexpbis>
+                         </APremierListeexp>
+                        </AAppelfct>
+                       </AAppelfctExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </APlusExp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                </AParenthesesExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </ARetourInstr>
+         <AFinalListeinst>
+          <AEpsilon>
+          </AEpsilon>
+         </AFinalListeinst>
+        </ARecursifListeinst>
+       </AInstrbloc>
+      </ASinonInstr>
+      <AFinalListeinst>
+       <AEpsilon>
+       </AEpsilon>
+      </AFinalListeinst>
+     </ARecursifListeinst>
+    </AInstrbloc>
+   </ADecfonc>
+   <ARecursifListedecfonc>
+    <ADecfonc>
+     <AVideOpttype>
+     </AVideOpttype>
+     <AVideListedecvar>
+      <AEpsilon>
+      </AEpsilon>
+     </AVideListedecvar>
+     <AVideListedecvar>
+      <AEpsilon>
+      </AEpsilon>
+     </AVideListedecvar>
+     <AInstrbloc>
+      <ARecursifListeinst>
+       <AEcritureInstr>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AAppelfctExp6>
+               <AAppelfct>
+                <APremierListeexp>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <ANombreExp6>
+                       </ANombreExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                 <AFinalListeexpbis>
+                  <AEpsilon>
+                  </AEpsilon>
+                 </AFinalListeexpbis>
+                </APremierListeexp>
+               </AAppelfct>
+              </AAppelfctExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AEcritureInstr>
+       <AFinalListeinst>
+        <AEpsilon>
+        </AEpsilon>
+       </AFinalListeinst>
+      </ARecursifListeinst>
+     </AInstrbloc>
+    </ADecfonc>
+    <AFinalListedecfonc>
+     <AEpsilon>
+     </AEpsilon>
+    </AFinalListedecfonc>
+   </ARecursifListedecfonc>
+  </ARecursifListedecfonc>
+ </AProgramme>
+</Start>
diff --git a/test/sc-ref/si1.sc b/test/sc-ref/si1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f2146b7ffa5af0fe1e053da5c9cc7c8e3588bf4a
--- /dev/null
+++ b/test/sc-ref/si1.sc
@@ -0,0 +1,74 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrsiInstr>
+       <ASanssinonInstrsi>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+        <AInstrbloc>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstfinalListeinst>
+          </ALinstfinalListeinst>
+         </ALinstrecListeinst>
+        </AInstrbloc>
+       </ASanssinonInstrsi>
+      </AInstrsiInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/si2.sc b/test/sc-ref/si2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..ac02bca9f7d61142662d49d1fb0b51f16d66a508
--- /dev/null
+++ b/test/sc-ref/si2.sc
@@ -0,0 +1,100 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrsiInstr>
+       <AAvecsinonInstrsi>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+        <AInstrbloc>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstfinalListeinst>
+          </ALinstfinalListeinst>
+         </ALinstrecListeinst>
+        </AInstrbloc>
+        <AInstrsinon>
+         <AInstrbloc>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </AInstrbloc>
+        </AInstrsinon>
+       </AAvecsinonInstrsi>
+      </AInstrsiInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/si3.sc b/test/sc-ref/si3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..d209790b642114496108c5f9c419fbe1388ab2bd
--- /dev/null
+++ b/test/sc-ref/si3.sc
@@ -0,0 +1,120 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrsiInstr>
+       <AAvecsinonInstrsi>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+        <AInstrbloc>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstfinalListeinst>
+          </ALinstfinalListeinst>
+         </ALinstrecListeinst>
+        </AInstrbloc>
+        <AInstrsinon>
+         <AInstrbloc>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </AInstrbloc>
+        </AInstrsinon>
+       </AAvecsinonInstrsi>
+      </AInstrsiInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/si4.sc b/test/sc-ref/si4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..d209790b642114496108c5f9c419fbe1388ab2bd
--- /dev/null
+++ b/test/sc-ref/si4.sc
@@ -0,0 +1,120 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrsiInstr>
+       <AAvecsinonInstrsi>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+        <AInstrbloc>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstfinalListeinst>
+          </ALinstfinalListeinst>
+         </ALinstrecListeinst>
+        </AInstrbloc>
+        <AInstrsinon>
+         <AInstrbloc>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </AInstrbloc>
+        </AInstrsinon>
+       </AAvecsinonInstrsi>
+      </AInstrsiInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/si5.sc b/test/sc-ref/si5.sc
new file mode 100644
index 0000000000000000000000000000000000000000..63490b683435b938ff34909ca226d879b5d0c5c0
--- /dev/null
+++ b/test/sc-ref/si5.sc
@@ -0,0 +1,152 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrsiInstr>
+       <ASanssinonInstrsi>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <AParenthesesExp6>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AParenthesesExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+        <AInstrbloc>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstrecListeinst>
+           <AInstrsiInstr>
+            <ASanssinonInstrsi>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AParenthesesExp6>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AParenthesesExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+             <AInstrbloc>
+              <ALinstrecListeinst>
+               <AInstrecritureInstr>
+                <AInstrecriture>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <ANombreExp6>
+                       </ANombreExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                </AInstrecriture>
+               </AInstrecritureInstr>
+               <ALinstfinalListeinst>
+               </ALinstfinalListeinst>
+              </ALinstrecListeinst>
+             </AInstrbloc>
+            </ASanssinonInstrsi>
+           </AInstrsiInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </ALinstrecListeinst>
+        </AInstrbloc>
+       </ASanssinonInstrsi>
+      </AInstrsiInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/sub1.sc b/test/sc-ref/sub1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..67c24adf3829eaa4aca3793b722206f5a8caa7e9
--- /dev/null
+++ b/test/sc-ref/sub1.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AMoinsExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AMoinsExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/sub2.sc b/test/sc-ref/sub2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..67c24adf3829eaa4aca3793b722206f5a8caa7e9
--- /dev/null
+++ b/test/sc-ref/sub2.sc
@@ -0,0 +1,44 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AMoinsExp3>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AMoinsExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/sub3.sc b/test/sc-ref/sub3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..8cc3d2b070cda1bdeb6b60619aa5fc2d16057501
--- /dev/null
+++ b/test/sc-ref/sub3.sc
@@ -0,0 +1,52 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstrecritureInstr>
+       <AInstrecriture>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AMoinsExp3>
+            <AMoinsExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AMoinsExp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AMoinsExp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstrecriture>
+      </AInstrecritureInstr>
+      <ALinstfinalListeinst>
+      </ALinstfinalListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tab1.sc b/test/sc-ref/tab1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..566a603ace561fd55c0f13996bb976e7588f9a2b
--- /dev/null
+++ b/test/sc-ref/tab1.sc
@@ -0,0 +1,238 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvartableauDecvar>
+    </ADecvartableauDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVartabVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AVartabVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AVartabVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstraffectInstr>
+         <AInstraffect>
+          <AVartabVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstraffect>
+        </AInstraffectInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVartabVar>
+                   <AExp1Exp>
+                    <AExp2Exp1>
+                     <AExp3Exp2>
+                      <AExp4Exp3>
+                       <AExp5Exp4>
+                        <AExp6Exp5>
+                         <ANombreExp6>
+                         </ANombreExp6>
+                        </AExp6Exp5>
+                       </AExp5Exp4>
+                      </AExp4Exp3>
+                     </AExp3Exp2>
+                    </AExp2Exp1>
+                   </AExp1Exp>
+                  </AVartabVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVartabVar>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AVartabVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVartabVar>
+                     <AExp1Exp>
+                      <AExp2Exp1>
+                       <AExp3Exp2>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <ANombreExp6>
+                           </ANombreExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                       </AExp3Exp2>
+                      </AExp2Exp1>
+                     </AExp1Exp>
+                    </AVartabVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </ALinstrecListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tab2.sc b/test/sc-ref/tab2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f0b76e5deded94f2c2308e99fc8ac37294f6c524
--- /dev/null
+++ b/test/sc-ref/tab2.sc
@@ -0,0 +1,296 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvartableauDecvar>
+    </ADecvartableauDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <APlusExp3>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </APlusExp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AVartabVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstraffectInstr>
+         <AInstraffect>
+          <AVartabVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <APlusExp3>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVarsimpleVar>
+                   </AVarsimpleVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </APlusExp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstraffect>
+        </AInstraffectInstr>
+        <ALinstrecListeinst>
+         <AInstraffectInstr>
+          <AInstraffect>
+           <AVartabVar>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <APlusExp3>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVarsimpleVar>
+                    </AVarsimpleVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </APlusExp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AVartabVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstraffect>
+         </AInstraffectInstr>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVartabVar>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AVartabVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVartabVar>
+                     <AExp1Exp>
+                      <AExp2Exp1>
+                       <AExp3Exp2>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <ANombreExp6>
+                           </ANombreExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                       </AExp3Exp2>
+                      </AExp2Exp1>
+                     </AExp1Exp>
+                    </AVartabVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstrecListeinst>
+            <AInstrecritureInstr>
+             <AInstrecriture>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AExp3Exp2>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <AVarExp6>
+                     <AVartabVar>
+                      <AExp1Exp>
+                       <AExp2Exp1>
+                        <AExp3Exp2>
+                         <AExp4Exp3>
+                          <AExp5Exp4>
+                           <AExp6Exp5>
+                            <ANombreExp6>
+                            </ANombreExp6>
+                           </AExp6Exp5>
+                          </AExp5Exp4>
+                         </AExp4Exp3>
+                        </AExp3Exp2>
+                       </AExp2Exp1>
+                      </AExp1Exp>
+                     </AVartabVar>
+                    </AVarExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                </AExp3Exp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+             </AInstrecriture>
+            </AInstrecritureInstr>
+            <ALinstfinalListeinst>
+            </ALinstfinalListeinst>
+           </ALinstrecListeinst>
+          </ALinstrecListeinst>
+         </ALinstrecListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tab3.sc b/test/sc-ref/tab3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..bc763934d6940d7f5b02c03ad9e3db077415563d
--- /dev/null
+++ b/test/sc-ref/tab3.sc
@@ -0,0 +1,372 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvartableauDecvar>
+    </ADecvartableauDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstraffectInstr>
+         <AInstraffect>
+          <AVartabVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <APlusExp3>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVarsimpleVar>
+                   </AVarsimpleVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </APlusExp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstraffect>
+        </AInstraffectInstr>
+        <ALinstrecListeinst>
+         <AInstraffectInstr>
+          <AInstraffect>
+           <AVarsimpleVar>
+           </AVarsimpleVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstraffect>
+         </AInstraffectInstr>
+         <ALinstrecListeinst>
+          <AInstraffectInstr>
+           <AInstraffect>
+            <AVartabVar>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <APlusExp3>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <AVarExp6>
+                     <AVarsimpleVar>
+                     </AVarsimpleVar>
+                    </AVarExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVarsimpleVar>
+                    </AVarsimpleVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </APlusExp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AVartabVar>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <ANombreExp6>
+                  </ANombreExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstraffect>
+          </AInstraffectInstr>
+          <ALinstrecListeinst>
+           <AInstraffectInstr>
+            <AInstraffect>
+             <AVarsimpleVar>
+             </AVarsimpleVar>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstraffect>
+           </AInstraffectInstr>
+           <ALinstrecListeinst>
+            <AInstraffectInstr>
+             <AInstraffect>
+              <AVartabVar>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <APlusExp3>
+                   <AExp4Exp3>
+                    <AExp5Exp4>
+                     <AExp6Exp5>
+                      <AVarExp6>
+                       <AVarsimpleVar>
+                       </AVarsimpleVar>
+                      </AVarExp6>
+                     </AExp6Exp5>
+                    </AExp5Exp4>
+                   </AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AVarExp6>
+                      <AVarsimpleVar>
+                      </AVarsimpleVar>
+                     </AVarExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </APlusExp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AVartabVar>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AExp3Exp2>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <ANombreExp6>
+                    </ANombreExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                </AExp3Exp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+             </AInstraffect>
+            </AInstraffectInstr>
+            <ALinstrecListeinst>
+             <AInstrecritureInstr>
+              <AInstrecriture>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AVarExp6>
+                      <AVartabVar>
+                       <AExp1Exp>
+                        <AExp2Exp1>
+                         <AExp3Exp2>
+                          <AExp4Exp3>
+                           <AExp5Exp4>
+                            <AExp6Exp5>
+                             <ANombreExp6>
+                             </ANombreExp6>
+                            </AExp6Exp5>
+                           </AExp5Exp4>
+                          </AExp4Exp3>
+                         </AExp3Exp2>
+                        </AExp2Exp1>
+                       </AExp1Exp>
+                      </AVartabVar>
+                     </AVarExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AInstrecriture>
+             </AInstrecritureInstr>
+             <ALinstrecListeinst>
+              <AInstrecritureInstr>
+               <AInstrecriture>
+                <AExp1Exp>
+                 <AExp2Exp1>
+                  <AExp3Exp2>
+                   <AExp4Exp3>
+                    <AExp5Exp4>
+                     <AExp6Exp5>
+                      <AVarExp6>
+                       <AVartabVar>
+                        <AExp1Exp>
+                         <AExp2Exp1>
+                          <AExp3Exp2>
+                           <AExp4Exp3>
+                            <AExp5Exp4>
+                             <AExp6Exp5>
+                              <ANombreExp6>
+                              </ANombreExp6>
+                             </AExp6Exp5>
+                            </AExp5Exp4>
+                           </AExp4Exp3>
+                          </AExp3Exp2>
+                         </AExp2Exp1>
+                        </AExp1Exp>
+                       </AVartabVar>
+                      </AVarExp6>
+                     </AExp6Exp5>
+                    </AExp5Exp4>
+                   </AExp4Exp3>
+                  </AExp3Exp2>
+                 </AExp2Exp1>
+                </AExp1Exp>
+               </AInstrecriture>
+              </AInstrecritureInstr>
+              <ALinstrecListeinst>
+               <AInstrecritureInstr>
+                <AInstrecriture>
+                 <AExp1Exp>
+                  <AExp2Exp1>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <AVarExp6>
+                        <AVartabVar>
+                         <AExp1Exp>
+                          <AExp2Exp1>
+                           <AExp3Exp2>
+                            <AExp4Exp3>
+                             <AExp5Exp4>
+                              <AExp6Exp5>
+                               <ANombreExp6>
+                               </ANombreExp6>
+                              </AExp6Exp5>
+                             </AExp5Exp4>
+                            </AExp4Exp3>
+                           </AExp3Exp2>
+                          </AExp2Exp1>
+                         </AExp1Exp>
+                        </AVartabVar>
+                       </AVarExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                  </AExp2Exp1>
+                 </AExp1Exp>
+                </AInstrecriture>
+               </AInstrecritureInstr>
+               <ALinstfinalListeinst>
+               </ALinstfinalListeinst>
+              </ALinstrecListeinst>
+             </ALinstrecListeinst>
+            </ALinstrecListeinst>
+           </ALinstrecListeinst>
+          </ALinstrecListeinst>
+         </ALinstrecListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tab4.sc b/test/sc-ref/tab4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..b8a0b76caa1d7b2e504b9385c771aa4ae3802027
--- /dev/null
+++ b/test/sc-ref/tab4.sc
@@ -0,0 +1,278 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvartableauDecvar>
+    </ADecvartableauDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVartabVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AVartabVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVartabVar>
+                  <AExp1Exp>
+                   <AExp2Exp1>
+                    <AExp3Exp2>
+                     <AExp4Exp3>
+                      <AExp5Exp4>
+                       <AExp6Exp5>
+                        <ANombreExp6>
+                        </ANombreExp6>
+                       </AExp6Exp5>
+                      </AExp5Exp4>
+                     </AExp4Exp3>
+                    </AExp3Exp2>
+                   </AExp2Exp1>
+                  </AExp1Exp>
+                 </AVartabVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AVartabVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstraffectInstr>
+         <AInstraffect>
+          <AVartabVar>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <APlusExp3>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVartabVar>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AVartabVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <ANombreExp6>
+                 </ANombreExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </APlusExp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AVartabVar>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstraffect>
+        </AInstraffectInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVartabVar>
+                   <AExp1Exp>
+                    <AExp2Exp1>
+                     <AExp3Exp2>
+                      <AExp4Exp3>
+                       <AExp5Exp4>
+                        <AExp6Exp5>
+                         <ANombreExp6>
+                         </ANombreExp6>
+                        </AExp6Exp5>
+                       </AExp5Exp4>
+                      </AExp4Exp3>
+                     </AExp3Exp2>
+                    </AExp2Exp1>
+                   </AExp1Exp>
+                  </AVartabVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstrecListeinst>
+          <AInstrecritureInstr>
+           <AInstrecriture>
+            <AExp1Exp>
+             <AExp2Exp1>
+              <AExp3Exp2>
+               <AExp4Exp3>
+                <AExp5Exp4>
+                 <AExp6Exp5>
+                  <AVarExp6>
+                   <AVartabVar>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </AExp4Exp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AVartabVar>
+                  </AVarExp6>
+                 </AExp6Exp5>
+                </AExp5Exp4>
+               </AExp4Exp3>
+              </AExp3Exp2>
+             </AExp2Exp1>
+            </AExp1Exp>
+           </AInstrecriture>
+          </AInstrecritureInstr>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVartabVar>
+                     <AExp1Exp>
+                      <AExp2Exp1>
+                       <AExp3Exp2>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <ANombreExp6>
+                           </ANombreExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                       </AExp3Exp2>
+                      </AExp2Exp1>
+                     </AExp1Exp>
+                    </AVartabVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstfinalListeinst>
+           </ALinstfinalListeinst>
+          </ALinstrecListeinst>
+         </ALinstrecListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tantque1.sc b/test/sc-ref/tantque1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..4f9e5eb8a2f3daa485f0fb495c2f583e3e6f7b0f
--- /dev/null
+++ b/test/sc-ref/tantque1.sc
@@ -0,0 +1,168 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrtantqueInstr>
+        <AInstrtantque>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AParenthesesExp6>
+                <AExp1Exp>
+                 <AExp2Exp1>
+                  <AInfExp2>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <ANombreExp6>
+                       </ANombreExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                   <AExp4Exp3>
+                    <AExp5Exp4>
+                     <AExp6Exp5>
+                      <AVarExp6>
+                       <AVarsimpleVar>
+                       </AVarsimpleVar>
+                      </AVarExp6>
+                     </AExp6Exp5>
+                    </AExp5Exp4>
+                   </AExp4Exp3>
+                  </AInfExp2>
+                 </AExp2Exp1>
+                </AExp1Exp>
+               </AParenthesesExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AInstrbloc>
+          <ALinstrecListeinst>
+           <AInstrecritureInstr>
+            <AInstrecriture>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <AVarExp6>
+                    <AVarsimpleVar>
+                    </AVarsimpleVar>
+                   </AVarExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstrecriture>
+           </AInstrecritureInstr>
+           <ALinstrecListeinst>
+            <AInstraffectInstr>
+             <AInstraffect>
+              <AVarsimpleVar>
+              </AVarsimpleVar>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AExp3Exp2>
+                 <AMoinsExp3>
+                  <AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <AVarExp6>
+                      <AVarsimpleVar>
+                      </AVarsimpleVar>
+                     </AVarExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <ANombreExp6>
+                    </ANombreExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AMoinsExp3>
+                </AExp3Exp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+             </AInstraffect>
+            </AInstraffectInstr>
+            <ALinstfinalListeinst>
+            </ALinstfinalListeinst>
+           </ALinstrecListeinst>
+          </ALinstrecListeinst>
+         </AInstrbloc>
+        </AInstrtantque>
+       </AInstrtantqueInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <ANombreExp6>
+                </ANombreExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstfinalListeinst>
+        </ALinstfinalListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/tantque2.sc b/test/sc-ref/tantque2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..bc41df0c5ef2e8b5f3413607c1a7552f38ae4468
--- /dev/null
+++ b/test/sc-ref/tantque2.sc
@@ -0,0 +1,278 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrtantqueInstr>
+        <AInstrtantque>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AParenthesesExp6>
+                <AExp1Exp>
+                 <AExp2Exp1>
+                  <AInfExp2>
+                   <AExp3Exp2>
+                    <AExp4Exp3>
+                     <AExp5Exp4>
+                      <AExp6Exp5>
+                       <AVarExp6>
+                        <AVarsimpleVar>
+                        </AVarsimpleVar>
+                       </AVarExp6>
+                      </AExp6Exp5>
+                     </AExp5Exp4>
+                    </AExp4Exp3>
+                   </AExp3Exp2>
+                   <AExp4Exp3>
+                    <AExp5Exp4>
+                     <AExp6Exp5>
+                      <ANombreExp6>
+                      </ANombreExp6>
+                     </AExp6Exp5>
+                    </AExp5Exp4>
+                   </AExp4Exp3>
+                  </AInfExp2>
+                 </AExp2Exp1>
+                </AExp1Exp>
+               </AParenthesesExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+         <AInstrbloc>
+          <ALinstrecListeinst>
+           <AInstraffectInstr>
+            <AInstraffect>
+             <AVarsimpleVar>
+             </AVarsimpleVar>
+             <AExp1Exp>
+              <AExp2Exp1>
+               <AExp3Exp2>
+                <AExp4Exp3>
+                 <AExp5Exp4>
+                  <AExp6Exp5>
+                   <ANombreExp6>
+                   </ANombreExp6>
+                  </AExp6Exp5>
+                 </AExp5Exp4>
+                </AExp4Exp3>
+               </AExp3Exp2>
+              </AExp2Exp1>
+             </AExp1Exp>
+            </AInstraffect>
+           </AInstraffectInstr>
+           <ALinstrecListeinst>
+            <AInstrtantqueInstr>
+             <AInstrtantque>
+              <AExp1Exp>
+               <AExp2Exp1>
+                <AExp3Exp2>
+                 <AExp4Exp3>
+                  <AExp5Exp4>
+                   <AExp6Exp5>
+                    <AParenthesesExp6>
+                     <AExp1Exp>
+                      <AExp2Exp1>
+                       <AInfExp2>
+                        <AExp3Exp2>
+                         <AExp4Exp3>
+                          <AExp5Exp4>
+                           <AExp6Exp5>
+                            <AVarExp6>
+                             <AVarsimpleVar>
+                             </AVarsimpleVar>
+                            </AVarExp6>
+                           </AExp6Exp5>
+                          </AExp5Exp4>
+                         </AExp4Exp3>
+                        </AExp3Exp2>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <ANombreExp6>
+                           </ANombreExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                       </AInfExp2>
+                      </AExp2Exp1>
+                     </AExp1Exp>
+                    </AParenthesesExp6>
+                   </AExp6Exp5>
+                  </AExp5Exp4>
+                 </AExp4Exp3>
+                </AExp3Exp2>
+               </AExp2Exp1>
+              </AExp1Exp>
+              <AInstrbloc>
+               <ALinstrecListeinst>
+                <AInstrecritureInstr>
+                 <AInstrecriture>
+                  <AExp1Exp>
+                   <AExp2Exp1>
+                    <AExp3Exp2>
+                     <AExp4Exp3>
+                      <AExp5Exp4>
+                       <AExp6Exp5>
+                        <AVarExp6>
+                         <AVarsimpleVar>
+                         </AVarsimpleVar>
+                        </AVarExp6>
+                       </AExp6Exp5>
+                      </AExp5Exp4>
+                     </AExp4Exp3>
+                    </AExp3Exp2>
+                   </AExp2Exp1>
+                  </AExp1Exp>
+                 </AInstrecriture>
+                </AInstrecritureInstr>
+                <ALinstrecListeinst>
+                 <AInstrecritureInstr>
+                  <AInstrecriture>
+                   <AExp1Exp>
+                    <AExp2Exp1>
+                     <AExp3Exp2>
+                      <AExp4Exp3>
+                       <AExp5Exp4>
+                        <AExp6Exp5>
+                         <AVarExp6>
+                          <AVarsimpleVar>
+                          </AVarsimpleVar>
+                         </AVarExp6>
+                        </AExp6Exp5>
+                       </AExp5Exp4>
+                      </AExp4Exp3>
+                     </AExp3Exp2>
+                    </AExp2Exp1>
+                   </AExp1Exp>
+                  </AInstrecriture>
+                 </AInstrecritureInstr>
+                 <ALinstrecListeinst>
+                  <AInstraffectInstr>
+                   <AInstraffect>
+                    <AVarsimpleVar>
+                    </AVarsimpleVar>
+                    <AExp1Exp>
+                     <AExp2Exp1>
+                      <AExp3Exp2>
+                       <APlusExp3>
+                        <AExp4Exp3>
+                         <AExp5Exp4>
+                          <AExp6Exp5>
+                           <AVarExp6>
+                            <AVarsimpleVar>
+                            </AVarsimpleVar>
+                           </AVarExp6>
+                          </AExp6Exp5>
+                         </AExp5Exp4>
+                        </AExp4Exp3>
+                        <AExp5Exp4>
+                         <AExp6Exp5>
+                          <ANombreExp6>
+                          </ANombreExp6>
+                         </AExp6Exp5>
+                        </AExp5Exp4>
+                       </APlusExp3>
+                      </AExp3Exp2>
+                     </AExp2Exp1>
+                    </AExp1Exp>
+                   </AInstraffect>
+                  </AInstraffectInstr>
+                  <ALinstfinalListeinst>
+                  </ALinstfinalListeinst>
+                 </ALinstrecListeinst>
+                </ALinstrecListeinst>
+               </ALinstrecListeinst>
+              </AInstrbloc>
+             </AInstrtantque>
+            </AInstrtantqueInstr>
+            <ALinstrecListeinst>
+             <AInstraffectInstr>
+              <AInstraffect>
+               <AVarsimpleVar>
+               </AVarsimpleVar>
+               <AExp1Exp>
+                <AExp2Exp1>
+                 <AExp3Exp2>
+                  <APlusExp3>
+                   <AExp4Exp3>
+                    <AExp5Exp4>
+                     <AExp6Exp5>
+                      <AVarExp6>
+                       <AVarsimpleVar>
+                       </AVarsimpleVar>
+                      </AVarExp6>
+                     </AExp6Exp5>
+                    </AExp5Exp4>
+                   </AExp4Exp3>
+                   <AExp5Exp4>
+                    <AExp6Exp5>
+                     <ANombreExp6>
+                     </ANombreExp6>
+                    </AExp6Exp5>
+                   </AExp5Exp4>
+                  </APlusExp3>
+                 </AExp3Exp2>
+                </AExp2Exp1>
+               </AExp1Exp>
+              </AInstraffect>
+             </AInstraffectInstr>
+             <ALinstfinalListeinst>
+             </ALinstfinalListeinst>
+            </ALinstrecListeinst>
+           </ALinstrecListeinst>
+          </ALinstrecListeinst>
+         </AInstrbloc>
+        </AInstrtantque>
+       </AInstrtantqueInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varglob1.sc b/test/sc-ref/varglob1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..919a43405a186954fd65d20f556024a803342d62
--- /dev/null
+++ b/test/sc-ref/varglob1.sc
@@ -0,0 +1,66 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varglob2.sc b/test/sc-ref/varglob2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..96bbeca7222b19f46d627ecfb093807c15ae2f2c
--- /dev/null
+++ b/test/sc-ref/varglob2.sc
@@ -0,0 +1,74 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <APlusExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </APlusExp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varglob3.sc b/test/sc-ref/varglob3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..f4d53628cd5ec6c660d1ede103430f847eab9ffe
--- /dev/null
+++ b/test/sc-ref/varglob3.sc
@@ -0,0 +1,114 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarldecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+    <ADecvarListedecvarbis>
+     <ADecvarentierDecvar>
+     </ADecvarentierDecvar>
+    </ADecvarListedecvarbis>
+   </ADecvarldecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstfinalListeinst>
+         </ALinstfinalListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varglob4.sc b/test/sc-ref/varglob4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..9cd98686cc44b071aafdece2a2a3e71dfa15723f
--- /dev/null
+++ b/test/sc-ref/varglob4.sc
@@ -0,0 +1,102 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarldecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+    <ADecvarListedecvarbis>
+     <ADecvarentierDecvar>
+     </ADecvarentierDecvar>
+    </ADecvarListedecvarbis>
+   </ADecvarldecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <AInstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <APlusExp3>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </APlusExp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstfinalListeinst>
+        </ALinstfinalListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </AInstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varloc1.sc b/test/sc-ref/varloc1.sc
new file mode 100644
index 0000000000000000000000000000000000000000..55761e9d89bd27bd62295bbd738b4e7d185f96a2
--- /dev/null
+++ b/test/sc-ref/varloc1.sc
@@ -0,0 +1,66 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varloc2.sc b/test/sc-ref/varloc2.sc
new file mode 100644
index 0000000000000000000000000000000000000000..87932be72db67199f1418f43d14cc7552053427e
--- /dev/null
+++ b/test/sc-ref/varloc2.sc
@@ -0,0 +1,74 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <APlusExp3>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </APlusExp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varloc3.sc b/test/sc-ref/varloc3.sc
new file mode 100644
index 0000000000000000000000000000000000000000..4d594da2414c187d00f54716a040762856767655
--- /dev/null
+++ b/test/sc-ref/varloc3.sc
@@ -0,0 +1,114 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </AExp4Exp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstfinalListeinst>
+         </ALinstfinalListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varloc4.sc b/test/sc-ref/varloc4.sc
new file mode 100644
index 0000000000000000000000000000000000000000..e6e9d7d23f16e8c6619fedf40def802c5d87d4a7
--- /dev/null
+++ b/test/sc-ref/varloc4.sc
@@ -0,0 +1,102 @@
+<Start>
+ <ALdecfoncProgramme>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarldecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+      <ADecvarListedecvarbis>
+       <ADecvarentierDecvar>
+       </ADecvarentierDecvar>
+      </ADecvarListedecvarbis>
+     </ADecvarldecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstrecritureInstr>
+         <AInstrecriture>
+          <AExp1Exp>
+           <AExp2Exp1>
+            <AExp3Exp2>
+             <APlusExp3>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+              <AExp5Exp4>
+               <AExp6Exp5>
+                <AVarExp6>
+                 <AVarsimpleVar>
+                 </AVarsimpleVar>
+                </AVarExp6>
+               </AExp6Exp5>
+              </AExp5Exp4>
+             </APlusExp3>
+            </AExp3Exp2>
+           </AExp2Exp1>
+          </AExp1Exp>
+         </AInstrecriture>
+        </AInstrecritureInstr>
+        <ALinstfinalListeinst>
+        </ALinstfinalListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncfinalListedecfonc>
+   </ALdecfoncfinalListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ALdecfoncProgramme>
+</Start>
diff --git a/test/sc-ref/varloc5.sc b/test/sc-ref/varloc5.sc
new file mode 100644
index 0000000000000000000000000000000000000000..92acf2b7cd60eca257ef5a3d312d3c0b105b1642
--- /dev/null
+++ b/test/sc-ref/varloc5.sc
@@ -0,0 +1,136 @@
+<Start>
+ <ADecvarldecfoncProgramme>
+  <AOptdecvar>
+   <ADecvarListedecvar>
+    <ADecvarentierDecvar>
+    </ADecvarentierDecvar>
+   </ADecvarListedecvar>
+  </AOptdecvar>
+  <ALdecfoncrecListedecfonc>
+   <ADecvarinstrDecfonc>
+    <ASansparamListeparam>
+    </ASansparamListeparam>
+    <AOptdecvar>
+     <ADecvarListedecvar>
+      <ADecvarentierDecvar>
+      </ADecvarentierDecvar>
+     </ADecvarListedecvar>
+    </AOptdecvar>
+    <AInstrbloc>
+     <ALinstrecListeinst>
+      <AInstraffectInstr>
+       <AInstraffect>
+        <AVarsimpleVar>
+        </AVarsimpleVar>
+        <AExp1Exp>
+         <AExp2Exp1>
+          <AExp3Exp2>
+           <AExp4Exp3>
+            <AExp5Exp4>
+             <AExp6Exp5>
+              <ANombreExp6>
+              </ANombreExp6>
+             </AExp6Exp5>
+            </AExp5Exp4>
+           </AExp4Exp3>
+          </AExp3Exp2>
+         </AExp2Exp1>
+        </AExp1Exp>
+       </AInstraffect>
+      </AInstraffectInstr>
+      <ALinstrecListeinst>
+       <AInstrecritureInstr>
+        <AInstrecriture>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <AVarExp6>
+                <AVarsimpleVar>
+                </AVarsimpleVar>
+               </AVarExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstrecriture>
+       </AInstrecritureInstr>
+       <ALinstfinalListeinst>
+       </ALinstfinalListeinst>
+      </ALinstrecListeinst>
+     </ALinstrecListeinst>
+    </AInstrbloc>
+   </ADecvarinstrDecfonc>
+   <ALdecfoncrecListedecfonc>
+    <AInstrDecfonc>
+     <ASansparamListeparam>
+     </ASansparamListeparam>
+     <AInstrbloc>
+      <ALinstrecListeinst>
+       <AInstraffectInstr>
+        <AInstraffect>
+         <AVarsimpleVar>
+         </AVarsimpleVar>
+         <AExp1Exp>
+          <AExp2Exp1>
+           <AExp3Exp2>
+            <AExp4Exp3>
+             <AExp5Exp4>
+              <AExp6Exp5>
+               <ANombreExp6>
+               </ANombreExp6>
+              </AExp6Exp5>
+             </AExp5Exp4>
+            </AExp4Exp3>
+           </AExp3Exp2>
+          </AExp2Exp1>
+         </AExp1Exp>
+        </AInstraffect>
+       </AInstraffectInstr>
+       <ALinstrecListeinst>
+        <AInstrappelInstr>
+         <AInstrappel>
+          <AAppelfct>
+           <AFinalListeexp>
+           </AFinalListeexp>
+          </AAppelfct>
+         </AInstrappel>
+        </AInstrappelInstr>
+        <ALinstrecListeinst>
+         <AInstrecritureInstr>
+          <AInstrecriture>
+           <AExp1Exp>
+            <AExp2Exp1>
+             <AExp3Exp2>
+              <AExp4Exp3>
+               <AExp5Exp4>
+                <AExp6Exp5>
+                 <AVarExp6>
+                  <AVarsimpleVar>
+                  </AVarsimpleVar>
+                 </AVarExp6>
+                </AExp6Exp5>
+               </AExp5Exp4>
+              </AExp4Exp3>
+             </AExp3Exp2>
+            </AExp2Exp1>
+           </AExp1Exp>
+          </AInstrecriture>
+         </AInstrecritureInstr>
+         <ALinstfinalListeinst>
+         </ALinstfinalListeinst>
+        </ALinstrecListeinst>
+       </ALinstrecListeinst>
+      </ALinstrecListeinst>
+     </AInstrbloc>
+    </AInstrDecfonc>
+    <ALdecfoncfinalListedecfonc>
+    </ALdecfoncfinalListedecfonc>
+   </ALdecfoncrecListedecfonc>
+  </ALdecfoncrecListedecfonc>
+ </ADecvarldecfoncProgramme>
+</Start>
diff --git a/test/ts-ref/add1.ts b/test/ts-ref/add1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/add1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/add2.ts b/test/ts-ref/add2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/add2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/affect1.ts b/test/ts-ref/affect1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f223443e9d97dde78efbca5e6b59a7babdbdad38
--- /dev/null
+++ b/test/ts-ref/affect1.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+a	VAR  	entier	0
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/affect2.ts b/test/ts-ref/affect2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..53497cf7f8021a9a552389d69dc902e4b23b143f
--- /dev/null
+++ b/test/ts-ref/affect2.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+a	VAR  	entier	0
diff --git a/test/ts-ref/affect3.ts b/test/ts-ref/affect3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e4357a9135505f2224c6b9e93064d64a9fff071a
--- /dev/null
+++ b/test/ts-ref/affect3.ts
@@ -0,0 +1,7 @@
+TABLE GLOBALE
+f	FCT	nul	1
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+TABLE LOCALE : main
+a	VAR  	entier	0
diff --git a/test/ts-ref/and1.ts b/test/ts-ref/and1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/and1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/and2.ts b/test/ts-ref/and2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/and2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/and3.ts b/test/ts-ref/and3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/and3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/and4.ts b/test/ts-ref/and4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/and4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/and5.ts b/test/ts-ref/and5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/and5.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel-param1.ts b/test/ts-ref/appel-param1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc61134c3827ee792ca7b378d28620f75a27f793
--- /dev/null
+++ b/test/ts-ref/appel-param1.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+f	FCT	nul	1
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel-param2.ts b/test/ts-ref/appel-param2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eced11b659314938f13c703734267c683c173b19
--- /dev/null
+++ b/test/ts-ref/appel-param2.ts
@@ -0,0 +1,7 @@
+TABLE GLOBALE
+f	FCT	nul	2
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+b	PARAM	entier	4
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel-param3.ts b/test/ts-ref/appel-param3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c967f70cb314dc370e60659664d2a46f6549c1f4
--- /dev/null
+++ b/test/ts-ref/appel-param3.ts
@@ -0,0 +1,10 @@
+TABLE GLOBALE
+f	FCT	nul	5
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+b	PARAM	entier	4
+c	PARAM	entier	8
+d	PARAM	entier	12
+e	PARAM	entier	16
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel-retour1.ts b/test/ts-ref/appel-retour1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b80e9aa53dfc52f0246cdd41099ac2c03ab28ad
--- /dev/null
+++ b/test/ts-ref/appel-retour1.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+f	FCT	entier	1
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel1.ts b/test/ts-ref/appel1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0761e6dbf57494ec7710290ccfcf9071ee927b84
--- /dev/null
+++ b/test/ts-ref/appel1.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+f	FCT	nul	0
+main	FCT	nul	0
+TABLE LOCALE : f
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel2.ts b/test/ts-ref/appel2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e966d9f76a67f7a8918adaec9bc9a19483aa08c
--- /dev/null
+++ b/test/ts-ref/appel2.ts
@@ -0,0 +1,7 @@
+TABLE GLOBALE
+f	FCT	nul	0
+g	FCT	nul	0
+main	FCT	nul	0
+TABLE LOCALE : f
+TABLE LOCALE : g
+TABLE LOCALE : main
diff --git a/test/ts-ref/appel3.ts b/test/ts-ref/appel3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e966d9f76a67f7a8918adaec9bc9a19483aa08c
--- /dev/null
+++ b/test/ts-ref/appel3.ts
@@ -0,0 +1,7 @@
+TABLE GLOBALE
+f	FCT	nul	0
+g	FCT	nul	0
+main	FCT	nul	0
+TABLE LOCALE : f
+TABLE LOCALE : g
+TABLE LOCALE : main
diff --git a/test/ts-ref/div1.ts b/test/ts-ref/div1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/div1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/div2.ts b/test/ts-ref/div2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/div2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/div3.ts b/test/ts-ref/div3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/div3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/div4.ts b/test/ts-ref/div4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/div4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/ecrire1.ts b/test/ts-ref/ecrire1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/ecrire1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/ecrire2.ts b/test/ts-ref/ecrire2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/ecrire2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/egal1.ts b/test/ts-ref/egal1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/egal1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/egal2.ts b/test/ts-ref/egal2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/egal2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/egal3.ts b/test/ts-ref/egal3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/egal3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/err5.ts b/test/ts-ref/err5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f53ebb0c0cd3527a6dbdbbc3772fa451a2b381ab
--- /dev/null
+++ b/test/ts-ref/err5.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+f	FCT	0
+main	FCT	0
+TABLE LOCALE : f
+TABLE LOCALE : main
+f	VAR  	1	0
diff --git a/test/ts-ref/fibo.ts b/test/ts-ref/fibo.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49fbafbe67ba72c5ad7120295cea6d3ebf8781c7
--- /dev/null
+++ b/test/ts-ref/fibo.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+fibo	FCT	entier	1
+main	FCT	nul	0
+TABLE LOCALE : fibo
+n	PARAM	entier	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/inf1.ts b/test/ts-ref/inf1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/inf1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/inf2.ts b/test/ts-ref/inf2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/inf2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/inf3.ts b/test/ts-ref/inf3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/inf3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/inf4.ts b/test/ts-ref/inf4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/inf4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/modulo1.ts b/test/ts-ref/modulo1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/modulo1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/mult1.ts b/test/ts-ref/mult1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/mult1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/mult2.ts b/test/ts-ref/mult2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/mult2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/mult3.ts b/test/ts-ref/mult3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/mult3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/not1.ts b/test/ts-ref/not1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/not1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/not2.ts b/test/ts-ref/not2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/not2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/not3.ts b/test/ts-ref/not3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/not3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/or1.ts b/test/ts-ref/or1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/or1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/or2.ts b/test/ts-ref/or2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/or2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/or3.ts b/test/ts-ref/or3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/or3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/or4.ts b/test/ts-ref/or4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/or4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/or5.ts b/test/ts-ref/or5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/or5.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/parenth1.ts b/test/ts-ref/parenth1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/parenth1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/parenth2.ts b/test/ts-ref/parenth2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/parenth2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio23-1.ts b/test/ts-ref/prio23-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/prio23-1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio23-2.ts b/test/ts-ref/prio23-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/prio23-2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio23-3.ts b/test/ts-ref/prio23-3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/prio23-3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio23-4.ts b/test/ts-ref/prio23-4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6
--- /dev/null
+++ b/test/ts-ref/prio23-4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio34-1.ts b/test/ts-ref/prio34-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio34-1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio34-2.ts b/test/ts-ref/prio34-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio34-2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio34-3.ts b/test/ts-ref/prio34-3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio34-3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio34-4.ts b/test/ts-ref/prio34-4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio34-4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio45-1.ts b/test/ts-ref/prio45-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio45-1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio45-2.ts b/test/ts-ref/prio45-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio45-2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio45-3.ts b/test/ts-ref/prio45-3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio45-3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio45-4.ts b/test/ts-ref/prio45-4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio45-4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio56-1.ts b/test/ts-ref/prio56-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio56-1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio56-2.ts b/test/ts-ref/prio56-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio56-2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio67-1.ts b/test/ts-ref/prio67-1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio67-1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/prio67-2.ts b/test/ts-ref/prio67-2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/prio67-2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/rec1.ts b/test/ts-ref/rec1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b80e9aa53dfc52f0246cdd41099ac2c03ab28ad
--- /dev/null
+++ b/test/ts-ref/rec1.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+f	FCT	entier	1
+main	FCT	nul	0
+TABLE LOCALE : f
+a	PARAM	entier	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/si1.ts b/test/ts-ref/si1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/si1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/si2.ts b/test/ts-ref/si2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/si2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/si3.ts b/test/ts-ref/si3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/si3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/si4.ts b/test/ts-ref/si4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/si4.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/si5.ts b/test/ts-ref/si5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/si5.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/sub1.ts b/test/ts-ref/sub1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/sub1.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/sub2.ts b/test/ts-ref/sub2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/sub2.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/sub3.ts b/test/ts-ref/sub3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70
--- /dev/null
+++ b/test/ts-ref/sub3.ts
@@ -0,0 +1,3 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/tab1.ts b/test/ts-ref/tab1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1b4c6467f2c1f556c0b42c35a79c461c2631f187
--- /dev/null
+++ b/test/ts-ref/tab1.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+tab	TAB  	entier	0	3
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/tab2.ts b/test/ts-ref/tab2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a98869e3efd88268eb037b03c7c5071f1878027
--- /dev/null
+++ b/test/ts-ref/tab2.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+tab	TAB  	entier	0	5
+main	FCT	nul	0
+TABLE LOCALE : main
+base	VAR  	entier	0
diff --git a/test/ts-ref/tab3.ts b/test/ts-ref/tab3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f04742be14df03faf18e3b07b518008ced4a71cb
--- /dev/null
+++ b/test/ts-ref/tab3.ts
@@ -0,0 +1,6 @@
+TABLE GLOBALE
+tab	TAB  	entier	0	5
+main	FCT	nul	0
+TABLE LOCALE : main
+base	VAR  	entier	0
+offset	VAR  	entier	4
diff --git a/test/ts-ref/tab4.ts b/test/ts-ref/tab4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1b4c6467f2c1f556c0b42c35a79c461c2631f187
--- /dev/null
+++ b/test/ts-ref/tab4.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+tab	TAB  	entier	0	3
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/tantque1.ts b/test/ts-ref/tantque1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..53497cf7f8021a9a552389d69dc902e4b23b143f
--- /dev/null
+++ b/test/ts-ref/tantque1.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+a	VAR  	entier	0
diff --git a/test/ts-ref/tantque2.ts b/test/ts-ref/tantque2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c4be044e03ba45c24d46305bd1fb5bb4f514d67
--- /dev/null
+++ b/test/ts-ref/tantque2.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+a	VAR  	entier	0
+b	VAR  	entier	4
diff --git a/test/ts-ref/tri.ts b/test/ts-ref/tri.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d1113f42474df9a0285c37454b32da9e7d10240c
--- /dev/null
+++ b/test/ts-ref/tri.ts
@@ -0,0 +1,21 @@
+TABLE GLOBALE
+tab	TAB  	entier	0	10
+afficher	FCT	nul	1
+echanger	FCT	nul	2
+initialiser	FCT	nul	0
+main	FCT	nul	0
+trier	FCT	nul	1
+TABLE LOCALE : afficher
+i	VAR  	entier	0
+n	PARAM	entier	0
+TABLE LOCALE : echanger
+i	PARAM	entier	0
+j	PARAM	entier	4
+temp	VAR  	entier	0
+TABLE LOCALE : initialiser
+TABLE LOCALE : main
+TABLE LOCALE : trier
+echange	VAR  	entier	0
+j	VAR  	entier	4
+m	VAR  	entier	8
+n	PARAM	entier	0
diff --git a/test/ts-ref/varglob1.ts b/test/ts-ref/varglob1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..18438c4edf93ba9dc9903b8281bf08266bf7dbe3
--- /dev/null
+++ b/test/ts-ref/varglob1.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+variable	VAR  	entier	0
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/varglob2.ts b/test/ts-ref/varglob2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..18438c4edf93ba9dc9903b8281bf08266bf7dbe3
--- /dev/null
+++ b/test/ts-ref/varglob2.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+variable	VAR  	entier	0
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/varglob3.ts b/test/ts-ref/varglob3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..90950698b368592114f31360f2b9361097457401
--- /dev/null
+++ b/test/ts-ref/varglob3.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+var1	VAR  	entier	0
+var2	VAR  	entier	4
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/varglob4.ts b/test/ts-ref/varglob4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..90950698b368592114f31360f2b9361097457401
--- /dev/null
+++ b/test/ts-ref/varglob4.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+var1	VAR  	entier	0
+var2	VAR  	entier	4
+main	FCT	nul	0
+TABLE LOCALE : main
diff --git a/test/ts-ref/varloc1.ts b/test/ts-ref/varloc1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..43d6f3eedd8f11d4eca3d9abb7fe4c6c1688e2f4
--- /dev/null
+++ b/test/ts-ref/varloc1.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+variable	VAR  	entier	0
diff --git a/test/ts-ref/varloc2.ts b/test/ts-ref/varloc2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..43d6f3eedd8f11d4eca3d9abb7fe4c6c1688e2f4
--- /dev/null
+++ b/test/ts-ref/varloc2.ts
@@ -0,0 +1,4 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+variable	VAR  	entier	0
diff --git a/test/ts-ref/varloc3.ts b/test/ts-ref/varloc3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1fcf02194803eb9c87f62a700845524cad388338
--- /dev/null
+++ b/test/ts-ref/varloc3.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+var1	VAR  	entier	0
+var2	VAR  	entier	4
diff --git a/test/ts-ref/varloc4.ts b/test/ts-ref/varloc4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1fcf02194803eb9c87f62a700845524cad388338
--- /dev/null
+++ b/test/ts-ref/varloc4.ts
@@ -0,0 +1,5 @@
+TABLE GLOBALE
+main	FCT	nul	0
+TABLE LOCALE : main
+var1	VAR  	entier	0
+var2	VAR  	entier	4
diff --git a/test/ts-ref/varloc5.ts b/test/ts-ref/varloc5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dfa4f8a05e35f58eb73b6bc1b887fefea9723ec3
--- /dev/null
+++ b/test/ts-ref/varloc5.ts
@@ -0,0 +1,7 @@
+TABLE GLOBALE
+var1	VAR  	entier	0
+f	FCT	nul	0
+main	FCT	nul	0
+TABLE LOCALE : f
+var1	VAR  	entier	0
+TABLE LOCALE : main