diff --git a/tiger/gc_test.sh b/tiger/gc_test.sh
index 8548eb1..4c7d1c1 100755
--- a/tiger/gc_test.sh
+++ b/tiger/gc_test.sh
@@ -2,7 +2,7 @@
 
 (( i = 1 ))
 
-files=(array array_assignment comments conditions escapes functions gc hello hello1 hello2 hello3 hello5 integers lib loops merge nested prettyprint queens record spill strings vars)
+files=(comments conditions escapes functional functions gc hello hello1 hello2 hello3 hello5 integers lib merge nested pure pureClosure pureTree record spill strings vars)
 
 while true; do
     echo "******************************"
diff --git a/tiger/src/asm_gen.rs b/tiger/src/asm_gen.rs
index 3f31dfe..e0486ec 100644
--- a/tiger/src/asm_gen.rs
+++ b/tiger/src/asm_gen.rs
@@ -263,14 +263,6 @@ impl<F: Frame> Gen<F> {
                 self.emit(instruction);
             },
             Exp::BinOp { op: BinOp::Div, left: expr, right: box Exp::Const(num) } => {
-                let instruction = Instruction::Move {
-                    assembly: "mov 'd0, 0".to_string(),
-                    source: vec![],
-                    destination: vec![X86_64::rdx()],
-                    stack_destination: vec![],
-                    stack_source: vec![],
-                };
-                self.emit(instruction);
                 let instruction = Instruction::Move {
                     assembly: "mov 'd0, 's0".to_string(),
                     source: vec![self.munch_expression(*expr)],
@@ -288,6 +280,14 @@ impl<F: Frame> Gen<F> {
                     stack_source: vec![],
                 };
                 self.emit(instruction);
+                let instruction = Instruction::Move {
+                    assembly: "cqo".to_string(),
+                    source: vec![X86_64::rax()],
+                    destination: vec![X86_64::rdx()],
+                    stack_destination: vec![],
+                    stack_source: vec![],
+                };
+                self.emit(instruction);
                 let instruction = Instruction::Operation {
                     assembly: "idiv 's0".to_string(),
                     source: vec![immediate, X86_64::rax(), X86_64::rdx()],
@@ -308,17 +308,17 @@ impl<F: Frame> Gen<F> {
             },
             Exp::BinOp { op: BinOp::Div, left: box Exp::Const(num), right: expr } => {
                 let instruction = Instruction::Move {
-                    assembly: "mov 'd0, 0".to_string(),
+                    assembly: format!("mov 'd0, {}", num),
                     source: vec![],
-                    destination: vec![X86_64::rdx()],
+                    destination: vec![X86_64::rax()],
                     stack_destination: vec![],
                     stack_source: vec![],
                 };
                 self.emit(instruction);
                 let instruction = Instruction::Move {
-                    assembly: format!("mov 'd0, {}", num),
-                    source: vec![],
-                    destination: vec![X86_64::rax()],
+                    assembly: "cqo".to_string(),
+                    source: vec![X86_64::rax()],
+                    destination: vec![X86_64::rdx()],
                     stack_destination: vec![],
                     stack_source: vec![],
                 };
@@ -546,17 +546,17 @@ impl<F: Frame> Gen<F> {
             },
             Exp::BinOp { op: BinOp::Div, left, right } => {
                 let instruction = Instruction::Move {
-                    assembly: "mov 'd0, 0".to_string(),
-                    source: vec![],
-                    destination: vec![X86_64::rdx()],
+                    assembly: "mov 'd0, 's0".to_string(),
+                    source: vec![self.munch_expression(*left)],
+                    destination: vec![X86_64::rax()],
                     stack_destination: vec![],
                     stack_source: vec![],
                 };
                 self.emit(instruction);
                 let instruction = Instruction::Move {
-                    assembly: "mov 'd0, 's0".to_string(),
-                    source: vec![self.munch_expression(*left)],
-                    destination: vec![X86_64::rax()],
+                    assembly: "cqo".to_string(),
+                    source: vec![X86_64::rax()],
+                    destination: vec![X86_64::rdx()],
                     stack_destination: vec![],
                     stack_source: vec![],
                 };
diff --git a/tiger/src/ast.rs b/tiger/src/ast.rs
index dfcefcd..069ae61 100644
--- a/tiger/src/ast.rs
+++ b/tiger/src/ast.rs
@@ -21,16 +21,10 @@
 
 use position::WithPos;
 use symbol::{Symbol, SymbolWithPos};
-use temp::Label;
 
 #[allow(clippy::enum_variant_names)]
 #[derive(Clone, Debug, PartialEq)]
 pub enum Declaration {
-    ClassDeclaration {
-        declarations: Vec<DeclarationWithPos>,
-        name: SymbolWithPos,
-        parent_class: SymbolWithPos,
-    },
     Function(Vec<FuncDeclarationWithPos>),
     Type(Vec<TypeDecWithPos>),
     VariableDeclaration {
@@ -50,19 +44,14 @@ pub enum Expr {
         size: Box<ExprWithPos>,
         typ: SymbolWithPos,
     },
-    Assign {
-        expr: Box<ExprWithPos>,
-        var: Box<ExprWithPos>,
-    },
-    Break,
     Call {
         args: Vec<ExprWithPos>,
         function: Box<ExprWithPos>,
     },
     Closure {
         body: Box<ExprWithPos>,
+        name: SymbolWithPos,
         params: Vec<FieldWithPos>,
-        pure: bool,
         result: Option<SymbolWithPos>,
     },
     ClosureParamField {
@@ -76,9 +65,6 @@ pub enum Expr {
         ident: SymbolWithPos,
         this: Box<ExprWithPos>,
     },
-    FunctionPointer {
-        label: Label,
-    },
     FunctionPointerCall {
         args: Vec<ExprWithPos>,
         closure_name: Symbol,
@@ -96,14 +82,6 @@ pub enum Expr {
         body: Box<ExprWithPos>,
         declarations: Vec<DeclarationWithPos>,
     },
-    MethodCall {
-        args: Vec<ExprWithPos>,
-        method: SymbolWithPos,
-        this: Box<ExprWithPos>,
-    },
-    New {
-        class_name: SymbolWithPos,
-    },
     Nil,
     Oper {
         left: Box<ExprWithPos>,
@@ -123,10 +101,6 @@ pub enum Expr {
         this: Box<ExprWithPos>,
     },
     Variable(SymbolWithPos),
-    While {
-        body: Box<ExprWithPos>,
-        test: Box<ExprWithPos>,
-    },
 }
 
 pub type ExprWithPos = WithPos<Expr>;
@@ -145,7 +119,6 @@ pub struct FuncDeclaration {
     pub body: ExprWithPos,
     pub name: SymbolWithPos,
     pub params: Vec<FieldWithPos>,
-    pub pure: bool,
     pub result: Option<SymbolWithPos>,
 }
 
@@ -204,7 +177,3 @@ pub struct TypeDec {
 pub type TypeDecWithPos = WithPos<TypeDec>;
 
 pub type TyWithPos = WithPos<Ty>;
-
-pub fn dummy_var_expr(symbol: Symbol) -> ExprWithPos {
-    WithPos::dummy(Expr::Variable(WithPos::dummy(symbol)))
-}
diff --git a/tiger/src/collector.rs b/tiger/src/collector.rs
index 3020b1a..633ab1f 100644
--- a/tiger/src/collector.rs
+++ b/tiger/src/collector.rs
@@ -30,7 +30,6 @@ use std::ptr;
 
 use data_layout::{
     ARRAY_DATA_LAYOUT_SIZE,
-    CLASS_DATA_LAYOUT_SIZE,
     RECORD_DATA_LAYOUT_SIZE,
     STRING_DATA_LAYOUT_SIZE,
     STRING_TYPE,
@@ -42,14 +41,12 @@ const SHOW_STATS: bool = false;
 #[derive(Debug)]
 pub enum Layout {
     Array(usize, bool),
-    Class(*const c_char),
     Record(*const c_char),
     String(usize),
 }
 
 const ARRAY_TYPE: usize = 0;
 const RECORD_TYPE: usize = 1;
-const CLASS_TYPE: usize = 3;
 
 impl Layout {
     fn write_repr(&self, mut ptr: *mut usize) {
@@ -62,11 +59,6 @@ impl Layout {
                     ptr = ptr.offset(1);
                     ptr::write(ptr, is_pointer as usize);
                 },
-                Layout::Class(data_layout) => {
-                    ptr::write(ptr, CLASS_TYPE);
-                    ptr = ptr.offset(1);
-                    ptr::write(ptr, data_layout as usize)
-                },
                 Layout::Record(data_layout) => {
                     ptr::write(ptr, RECORD_TYPE);
                     ptr = ptr.offset(1);
@@ -84,12 +76,6 @@ impl Layout {
     fn size(&self) -> usize {
         match *self {
             Layout::Array(length, _) => (length + ARRAY_DATA_LAYOUT_SIZE) * WORD_SIZE,
-            Layout::Class(data_layout) => {
-                let string_ptr = string_offset(data_layout);
-                let fields = unsafe { CStr::from_ptr(string_ptr) };
-                let field_count = fields.to_bytes().len() + CLASS_DATA_LAYOUT_SIZE;
-                field_count * WORD_SIZE
-            },
             Layout::Record(data_layout) => {
                 let string_ptr = string_offset(data_layout);
                 let fields = unsafe { CStr::from_ptr(string_ptr) };
@@ -233,14 +219,6 @@ impl Collector {
                         }
                     }
                 },
-                CLASS_TYPE => {
-                    for (i, &field_layout) in record_layout(pointer).iter().enumerate() {
-                        if field_layout == b'p' {
-                            let field = class_field(pointer, i);
-                            self.dfs(field);
-                        }
-                    }
-                },
                 RECORD_TYPE => {
                     for (i, &field_layout) in record_layout(pointer).iter().enumerate() {
                         if field_layout == b'p' {
@@ -281,17 +259,6 @@ impl Collector {
                     }
                 }
             },
-            CLASS_TYPE => {
-                for (i, &field_layout) in record_layout(pointer).iter().enumerate() {
-                    if field_layout == b'p' {
-                        let field = class_field(pointer, i);
-                        if self.in_heap(field) {
-                            locations.insert(class_field_address(pointer, i) as usize, field);
-                            self.dfs_locations(field, locations);
-                        }
-                    }
-                }
-            },
             RECORD_TYPE => {
                 for (i, &field_layout) in record_layout(pointer).iter().enumerate() {
                     if field_layout == b'p' {
@@ -437,19 +404,6 @@ fn fetch_pointer_map() -> HashMap<usize, Vec<Stack>> {
     pointer_map
 }
 
-fn class_field(ptr: usize, index: usize) -> usize {
-    unsafe {
-        ptr::read_unaligned(class_field_address(ptr, index))
-    }
-}
-
-fn class_field_address(ptr: usize, index: usize) -> *const usize {
-    let ptr = ptr as *const usize;
-    unsafe {
-        ptr.add(index + CLASS_DATA_LAYOUT_SIZE)
-    }
-}
-
 fn field(ptr: usize, index: usize) -> usize {
     unsafe {
         ptr::read_unaligned(field_address(ptr, index))
@@ -484,9 +438,6 @@ fn size_of(ptr: usize) -> usize {
                 let ptr = ptr.offset(1);
                 ptr::read_unaligned(ptr) + ARRAY_DATA_LAYOUT_SIZE * WORD_SIZE
             },
-            CLASS_TYPE => {
-                (field_count(ptr as usize) + CLASS_DATA_LAYOUT_SIZE) * WORD_SIZE
-            },
             RECORD_TYPE => {
                 (field_count(ptr as usize) + RECORD_DATA_LAYOUT_SIZE) * WORD_SIZE
             },
diff --git a/tiger/src/data_layout.rs b/tiger/src/data_layout.rs
index 2f76467..cb2a1ec 100644
--- a/tiger/src/data_layout.rs
+++ b/tiger/src/data_layout.rs
@@ -22,9 +22,6 @@
 // Type, Size, Is pointer.
 pub const ARRAY_DATA_LAYOUT_SIZE: usize = 3;
 
-// Type, String of is pointer, Vtable pointer.
-pub const CLASS_DATA_LAYOUT_SIZE: usize = 3;
-
 // Type, String of is pointer.
 pub const RECORD_DATA_LAYOUT_SIZE: usize = 2;
 
diff --git a/tiger/src/env.rs b/tiger/src/env.rs
index 44ebec4..92ee3a5 100644
--- a/tiger/src/env.rs
+++ b/tiger/src/env.rs
@@ -19,31 +19,53 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
 use escape::{DepthEscape, EscapeEnv};
 use frame::Frame;
-use gen;
-use gen::{Access, Level};
+use gen::Access;
 use position::WithPos;
-use symbol::{Strings, Symbol, Symbols};
+use symbol::{
+    Strings,
+    Symbol,
+    Symbols,
+    SymbolWithPos,
+};
 use temp::Label;
-use types::{Type, Unique};
+use types::Type;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ClosureField {
+    pub ident: Symbol,
+    pub typ: Type,
+}
+
+impl Eq for ClosureField {
+}
+
+impl PartialOrd for ClosureField {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ClosureField {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.ident.cmp(&other.ident)
+    }
+}
 
 #[derive(Clone, Debug)]
 pub enum Entry<F: Clone + Frame> {
-    ClassField {
-        class: Type,
-    },
     Fun {
-        access_outside_vars: bool,
         external: bool,
         label: Label,
-        level: Level<F>,
         parameters: Vec<Type>,
-        pure: bool,
+        param_type_symbols: Vec<SymbolWithPos>,
         result: Type,
+        result_symbol: Option<SymbolWithPos>,
     },
     RecordField {
         record: Type,
@@ -68,21 +90,10 @@ impl<F: Clone + Frame> Env<F> {
         let string_symbol = type_env.symbol("string");
         type_env.enter(string_symbol, Type::String);
 
-        let object_symbol = type_env.symbol("Object");
         let answer_symbol = type_env.symbol("answer");
         let cont_symbol = type_env.symbol("cont");
         let string_consumer_symbol = type_env.symbol("stringConsumer");
 
-        let object_class = Type::Class {
-            data_layout: String::new(),
-            fields: vec![],
-            methods: vec![],
-            name: object_symbol,
-            parent_class: None,
-            unique: Unique::new(),
-            vtable_name: Label::with_name("__vtable_Object"),
-        };
-
         let var_env = Symbols::new(Rc::clone(strings));
         let mut env = Self {
             escape_env,
@@ -90,12 +101,10 @@ impl<F: Clone + Frame> Env<F> {
             var_env,
         };
 
-        for (name, (param_types, return_type, pure)) in env.external_functions() {
-            env.add_function(name, param_types, return_type, pure);
+        for (name, (param_types, return_type)) in env.external_functions() {
+            env.add_function(name, param_types, return_type);
         }
 
-        env.enter_type(object_symbol, object_class);
-
         env.enter_type(answer_symbol, Type::Answer);
         env.enter_type(cont_symbol, Type::Function {
             parameters: vec![],
@@ -109,16 +118,15 @@ impl<F: Clone + Frame> Env<F> {
         env
     }
 
-    fn add_function(&mut self, name: &str, parameters: Vec<Type>, result: Type, pure: bool) {
+    fn add_function(&mut self, name: &str, parameters: Vec<Type>, result: Type) {
         let symbol = self.var_env.symbol(name);
         let entry = Entry::Fun {
-            access_outside_vars: false,
             external: true,
             label: Label::with_name(name),
-            level: gen::outermost(), // FIXME: Might want to create a new level.
             parameters,
-            pure,
+            param_type_symbols: vec![],
             result,
+            result_symbol: None,
         };
         self.var_env.enter(symbol, entry);
     }
@@ -178,29 +186,27 @@ impl<F: Clone + Frame> Env<F> {
         self.var_env.name(symbol)
     }
 
-    pub fn external_functions(&mut self) -> BTreeMap<&'static str, (Vec<Type>, Type, bool)> {
+    pub fn external_functions(&mut self) -> BTreeMap<&'static str, (Vec<Type>, Type)> {
         let mut functions = BTreeMap::new();
-        functions.insert("print", (vec![Type::String], Type::Unit, false));
-        functions.insert("printi", (vec![Type::Int], Type::Unit, false));
-        functions.insert("flush", (vec![], Type::Unit, false));
-        functions.insert("getchar", (vec![], Type::String, false));
-        functions.insert("ord", (vec![Type::String], Type::Int, true));
-        functions.insert("chr", (vec![Type::Int], Type::String, true));
-        functions.insert("size", (vec![Type::String], Type::Int, true));
-        functions.insert("substring", (vec![Type::String, Type::Int, Type::Int], Type::String, true));
-        functions.insert("concat", (vec![Type::String, Type::String], Type::String, true));
-        functions.insert("not", (vec![Type::Int], Type::Int, true));
-        functions.insert("stringEqual", (vec![Type::String, Type::String], Type::Int, true));
+        functions.insert("ord", (vec![Type::String], Type::Int));
+        functions.insert("chr", (vec![Type::Int], Type::String));
+        functions.insert("size", (vec![Type::String], Type::Int));
+        functions.insert("substring", (vec![Type::String, Type::Int, Type::Int], Type::String));
+        functions.insert("concat", (vec![Type::String, Type::String], Type::String));
+        functions.insert("not", (vec![Type::Int], Type::Int));
+        functions.insert("stringEqual", (vec![Type::String, Type::String], Type::Int));
 
         let cont = Type::Name(WithPos::dummy(self.type_env.symbol("cont")), None);
-        functions.insert("printP", (vec![Type::String, cont.clone()], Type::Answer, true));
-        functions.insert("flushP", (vec![cont], Type::Answer, true));
-        functions.insert("getcharP", (vec![Type::Name(WithPos::dummy(self.type_env.symbol("stringConsumer")), None)], Type::Answer, true));
-        functions.insert("exit", (vec![], Type::Answer, true));
-
-        functions.insert("allocClass", (vec![Type::Int], Type::Int, true));
-        functions.insert("allocRecord", (vec![Type::Int], Type::Int, true));
-        functions.insert("initArray", (vec![Type::Int, Type::Int], Type::Int, true));
+        functions.insert("debug", (vec![Type::String], Type::Answer));
+        functions.insert("debugInt", (vec![Type::Int], Type::Answer));
+        functions.insert("printi", (vec![Type::Int, cont.clone()], Type::Answer));
+        functions.insert("print", (vec![Type::String, cont.clone()], Type::Answer));
+        functions.insert("flush", (vec![cont], Type::Answer));
+        functions.insert("getchar", (vec![Type::Name(WithPos::dummy(self.type_env.symbol("stringConsumer")), None)], Type::Answer));
+        functions.insert("tigerExit", (vec![], Type::Answer));
+
+        functions.insert("allocRecord", (vec![Type::Int], Type::Int));
+        functions.insert("initArray", (vec![Type::Int, Type::Int], Type::Int));
         functions
     }
 }
diff --git a/tiger/src/error.rs b/tiger/src/error.rs
index 56d3c51..630ef88 100644
--- a/tiger/src/error.rs
+++ b/tiger/src/error.rs
@@ -29,27 +29,12 @@ use self::Error::*;
 use symbol::Symbols;
 use terminal::Terminal;
 use token::Tok;
-use types::{FunctionType, Type};
+use types::Type;
 
 pub type Result<T> = result::Result<T, Error>;
 
 #[derive(Clone, Debug)]
 pub enum Error {
-    Assign {
-        pos: Pos,
-    },
-    BreakOutsideLoop {
-        pos: Pos,
-    },
-    CannotAccessOutsideVars {
-        pos: Pos,
-    },
-    CannotAssignInPureFun {
-        pos: Pos,
-    },
-    CannotCallImpureFun {
-        pos: Pos,
-    },
     CannotIndex {
         pos: Pos,
         typ: Type,
@@ -67,11 +52,6 @@ pub enum Error {
         pos: Pos,
         struct_name: String,
     },
-    FunctionType {
-        expected: FunctionType,
-        pos: Pos,
-        unexpected: FunctionType,
-    },
     InvalidEscape {
         escape: String,
         pos: Pos,
@@ -88,14 +68,7 @@ pub enum Error {
     },
     Msg(String),
     Multi(Vec<Error>),
-    NoLoopInPureFun {
-        pos: Pos,
-    },
-    NotAClass {
-        pos: Pos,
-        typ: Type,
-    },
-    NotARecordOrClass {
+    NotARecord {
         pos: Pos,
         typ: Type,
     },
@@ -150,30 +123,6 @@ impl Error {
         }
         eprint!("{}{}error: {}", terminal.bold(), terminal.red(), terminal.reset_color());
         match *self {
-            Assign { pos } => {
-                eprintln!("Can only assign to variable, field or array element{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
-            BreakOutsideLoop { pos } => {
-                eprintln!("Break statement used outside of loop{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-            },
-            CannotCallImpureFun { pos } => {
-                eprintln!("Cannot call impure functions in pure functions{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
-            CannotAccessOutsideVars { pos } => {
-                eprintln!("Cannot convert into a closure a function that accesses variables declared outside of it{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
-            CannotAssignInPureFun { pos } => {
-                eprintln!("Cannot assign in pure functions{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
             CannotIndex { pos, ref typ } => {
                 eprintln!("Cannot index value of type `{}`{}", typ.show(symbols), terminal.end_bold());
                 pos.show(symbols, terminal)
@@ -192,11 +141,6 @@ impl Error {
                 eprintln!("Extra field `{}` in struct of type `{}`{}", ident, struct_name, terminal.end_bold());
                 pos.show(symbols, terminal);
             },
-            Error::FunctionType { ref expected, pos, ref unexpected } => {
-                eprintln!("Overridden method should have the same type as the inherited method:\nunexpected {}\n expecting {}{}", unexpected.show(symbols), expected.show(symbols), terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
             InvalidEscape { ref escape, pos } => {
                 eprintln!("Invalid escape \\{}{}", escape, terminal.end_bold());
                 pos.show(symbols, terminal);
@@ -213,18 +157,8 @@ impl Error {
             },
             Msg(ref string) => eprintln!("{}", string),
             Multi(_) => unreachable!(),
-            NoLoopInPureFun { pos } => {
-                eprintln!("Cannot use loops in pure functions{}", terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
-            NotAClass { pos, ref typ } => {
-                eprintln!("Type `{}` is not a class type{}", typ.show(symbols), terminal.end_bold());
-                pos.show(symbols, terminal);
-                highlight_line(pos, symbols, terminal)?;
-            },
-            NotARecordOrClass { pos, ref typ } => {
-                eprintln!("Type `{}` is not a struct or a class type{}", typ.show(symbols), terminal.end_bold());
+            NotARecord { pos, ref typ } => {
+                eprintln!("Type `{}` is not a struct{}", typ.show(symbols), terminal.end_bold());
                 pos.show(symbols, terminal);
                 highlight_line(pos, symbols, terminal)?;
             },
@@ -255,6 +189,7 @@ impl Error {
             UnexpectedField { ref ident, pos, ref struct_name } => {
                 eprintln!("Unexpected field `{}` in struct of type `{}`{}", ident, struct_name, terminal.end_bold());
                 pos.show(symbols, terminal);
+                highlight_line(pos, symbols, terminal)?;
             },
             UnexpectedToken { ref expected, pos, ref unexpected } => {
                 eprintln!("Unexpected token {}, expecting {}{}", unexpected, expected, terminal.end_bold());
diff --git a/tiger/src/escape.rs b/tiger/src/escape.rs
index e5839f4..3e4a8a2 100644
--- a/tiger/src/escape.rs
+++ b/tiger/src/escape.rs
@@ -57,16 +57,12 @@ impl EscapeFinder {
 
     fn visit_dec(&mut self, declaration: &DeclarationWithPos, depth: u32) {
         match declaration.node {
-            Declaration::ClassDeclaration { ref declarations, .. } => {
-                for declaration in declarations {
-                    self.visit_dec(declaration, depth + 1);
-                }
-            },
             Declaration::Function(ref declarations) => {
                 for &WithPos { node: FuncDeclaration { ref params, ref body, .. }, .. } in declarations {
                     for param in params {
+                        // TODO: param dig are considered escaping while they should not.
                         self.env.enter(param.node.name, DepthEscape {
-                            depth,
+                            depth: depth + 1,
                             escape: false,
                         });
                     }
@@ -75,7 +71,7 @@ impl EscapeFinder {
             },
             Declaration::Type(_) => (),
             Declaration::VariableDeclaration { ref init, name, .. } => {
-                self.visit_exp(init, depth + 1); // TODO: do we really need to increment depth here?
+                self.visit_exp(init, depth);
                 self.env.enter(name, DepthEscape {
                     depth,
                     escape: false,
@@ -90,22 +86,17 @@ impl EscapeFinder {
                 self.visit_exp(size, depth);
                 self.visit_exp(init, depth);
             },
-            Expr::Assign { ref expr, ref var } => {
-                self.visit_exp(var, depth);
-                self.visit_exp(expr, depth);
-            },
-            Expr::Break => {
-            },
             Expr::Closure { ref body, ref params, .. } => {
                 for param in params {
                     self.env.enter(param.node.name, DepthEscape {
-                        depth,
+                        depth: depth + 1,
                         escape: false,
                     });
                 }
                 self.visit_exp(body, depth + 1);
             },
-            Expr::Call { ref args, .. } => {
+            Expr::Call { ref args, ref function, .. } => {
+                self.visit_exp(function, depth);
                 for arg in args {
                     self.visit_exp(arg, depth);
                 }
@@ -118,7 +109,7 @@ impl EscapeFinder {
                     }
                 }
             },
-            Expr::ClosurePointer { .. } | Expr::FunctionPointer { .. } => (),
+            Expr::ClosurePointer { .. } => (),
             Expr::FunctionPointerCall { ref args, .. } => {
                 for arg in args {
                     self.visit_exp(arg, depth);
@@ -138,12 +129,6 @@ impl EscapeFinder {
                 }
                 self.visit_exp(body, depth);
             },
-            Expr::MethodCall { ref args, .. } => {
-                for arg in args {
-                    self.visit_exp(arg, depth);
-                }
-            },
-            Expr::New { .. } => (),
             Expr::Nil => (),
             Expr::Oper { ref left, oper: WithPos { node: Operator::Plus, .. }, ref right }
             | Expr::Oper { ref left, oper: WithPos { node: Operator::Minus, .. }, ref right }
@@ -179,10 +164,6 @@ impl EscapeFinder {
                 self.visit_exp(this, depth);
                 self.visit_exp(expr, depth);
             },
-            Expr::While { ref body, ref test } => {
-                self.visit_exp(test, depth);
-                self.visit_exp(body, depth);
-            },
         }
     }
 }
diff --git a/tiger/src/frame/mod.rs b/tiger/src/frame/mod.rs
index e9671c1..5389589 100644
--- a/tiger/src/frame/mod.rs
+++ b/tiger/src/frame/mod.rs
@@ -40,10 +40,6 @@ pub enum Fragment<F: Frame> {
         temp_map: TempMap,
     },
     Str(Label, String),
-    VTable {
-        class: Label,
-        methods: Vec<Label>,
-    },
 }
 
 pub trait Memory {
diff --git a/tiger/src/frame/x86_64.rs b/tiger/src/frame/x86_64.rs
index de26fe6..164977d 100644
--- a/tiger/src/frame/x86_64.rs
+++ b/tiger/src/frame/x86_64.rs
@@ -420,7 +420,7 @@ impl Frame for X86_64 {
     fn proc_entry_exit3(&self, body: Vec<Instruction>) -> Subroutine {
         let mut stack_size = -self.pointer;
         if stack_size % 16 != 0 {
-            // Align the stack of 16 bytes.
+            // Align the stack to 16 bytes.
             stack_size = (stack_size & !0xF) + 0x10;
         }
 
diff --git a/tiger/src/gen.rs b/tiger/src/gen.rs
index 733b6f3..9714644 100644
--- a/tiger/src/gen.rs
+++ b/tiger/src/gen.rs
@@ -20,12 +20,12 @@
  */
 
 use std::cell::RefCell;
+use std::collections::BTreeMap;
 use std::rc::Rc;
 
 use ast::Operator;
 use data_layout::{
     ARRAY_DATA_LAYOUT_SIZE,
-    CLASS_DATA_LAYOUT_SIZE,
     RECORD_DATA_LAYOUT_SIZE,
 };
 use frame::{Fragment, Frame, Memory};
@@ -64,16 +64,29 @@ use ir::_Statement::{
     Move,
     Sequence,
 };
-use semant::{FieldType, VTABLE_OFFSET};
 use temp::{Label, Temp, TempMap};
 
 #[allow(type_alias_bounds)]
 pub type Access<F: Frame> = (Level<F>, F::Access);
 
+pub struct IR<F: Frame> {
+    pub data: Vec<Fragment<F>>,
+    pub functions: BTreeMap<String, Fragment<F>>,
+}
+
+impl<F: Frame> IR<F> {
+    fn new() -> Self {
+        Self {
+            data: vec![],
+            functions: BTreeMap::new(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Level<F> {
     pub current: Rc<RefCell<F>>,
-    parent: Option<Box<Level<F>>>,
+    pub parent: Option<Box<Level<F>>>,
 }
 
 impl<F> Clone for Level<F> {
@@ -100,7 +113,7 @@ pub fn outermost<F: Frame>() -> Level<F> {
 
 impl<F: Frame> Level<F> {
     pub fn new(parent: &Level<F>, name: Label, mut formals: Vec<bool>) -> Level<F> {
-        formals.push(true); // for the static link.
+        formals.push(true); // Since all functions are converted to closure, add a parameter for the closure.
         Level {
             current: Rc::new(RefCell::new(F::new(name, formals))),
             parent: Some(Box::new(parent.clone())),
@@ -145,12 +158,8 @@ pub fn binary_oper(op: Operator, left: Exp, right: Exp) -> Exp {
     }
 }
 
-pub fn field_access<F: Frame>(var: Exp, field_index: usize, field_type: FieldType) -> Exp {
-    let offset =
-        match field_type {
-            FieldType::Class => CLASS_DATA_LAYOUT_SIZE,
-            FieldType::Record => RECORD_DATA_LAYOUT_SIZE,
-        };
+pub fn field_access<F: Frame>(var: Exp, field_index: usize) -> Exp {
+    let offset = RECORD_DATA_LAYOUT_SIZE;
     Mem(Box::new(BinOp {
         op: Plus,
         left: Box::new(var),
@@ -158,62 +167,6 @@ pub fn field_access<F: Frame>(var: Exp, field_index: usize, field_type: FieldTyp
     }))
 }
 
-fn call<F: Clone + Frame + PartialEq>(function: Exp, mut arguments: Vec<Exp>, parent_level: &Level<F>,
-    current_level: &Level<F>, collectable_return_type: bool, in_closure: bool) -> Exp
-{
-    if *current_level == *parent_level {
-        if in_closure {
-            panic!("Trying to access static link from inside a closure for a recursive call");
-        }
-
-        // For a recursive call, we simply pass the current static link, which represents the stack
-        // frame of the parent function.
-        let frame = current_level.current.borrow();
-        arguments.push(frame.exp(frame.formals().last().expect("static link").clone(), Exp::Temp(F::fp())));
-    }
-    else if current_level.parent.as_deref() == Some(parent_level) {
-        // When calling a function defined in the current frame, simply pass the current frame
-        // pointer for the static link.
-        arguments.push(Exp::Temp(F::fp()));
-    }
-    else {
-        // TODO: print an error as well.
-        if in_closure {
-            panic!("Trying to access static link from inside a closure");
-        }
-
-        // When calling a function defined in a parent frame, go up throught the static links.
-        let mut function_level = parent_level;
-        let mut var = Exp::Temp(F::fp());
-        loop {
-            if let Some(ref current_level) = current_level.parent {
-                if &**current_level == function_level {
-                    break;
-                }
-            }
-            let frame = function_level.current.borrow();
-            var = frame.exp(frame.formals().last().expect("static link").clone(), var);
-            match function_level.parent {
-                Some(ref parent) => function_level = parent,
-                None => break,
-            }
-        }
-        arguments.push(var);
-    }
-    Call {
-        arguments,
-        collectable_return_type,
-        function_expr: Box::new(function),
-        return_label: Label::new(),
-    }
-}
-
-pub fn function_call<F: Clone + Frame + PartialEq>(label: &Label, arguments: Vec<Exp>, parent_level: &Level<F>,
-    current_level: &Level<F>, collectable_return_type: bool, in_closure: bool) -> Exp
-{
-    call(Name(label.clone()), arguments, parent_level, current_level, collectable_return_type, in_closure)
-}
-
 pub fn function_pointer_call(function_pointer: Exp, arguments: Vec<Exp>, collectable_return_type: bool) -> Exp {
     Call {
         arguments,
@@ -223,29 +176,6 @@ pub fn function_pointer_call(function_pointer: Exp, arguments: Vec<Exp>, collect
     }
 }
 
-pub fn method_call<F: Clone + Frame + PartialEq>(index: usize, arguments: Vec<Exp>, parent_level: &Level<F>,
-    current_level: &Level<F>, collectable_return_type: bool, in_closure: bool) -> Exp
-{
-    let vtable = Mem(Box::new(BinOp {
-        op: Plus,
-        left: Box::new(arguments[0].clone()),
-        right: Box::new(Const(F::WORD_SIZE * VTABLE_OFFSET as i64)),
-    }));
-    let function_ptr = Mem(Box::new(BinOp {
-        op: Plus,
-        left: Box::new(vtable),
-        right: Box::new(Const(F::WORD_SIZE * index as i64)),
-    }));
-    call(function_ptr, arguments, parent_level, current_level, collectable_return_type, in_closure)
-}
-
-pub fn goto(label: Label) -> Exp {
-    ExpSequence(
-        Box::new(Jump(Name(label.clone()), vec![label]).into()),
-        Box::new(unit()),
-    )
-}
-
 pub fn if_expression<F: Clone + Frame>(test_expr: Exp, if_expr: Exp, else_expr: Option<Exp>, level: &Level<F>) -> Exp {
     let result = alloc_local(level, false);
     let true_label = Label::new();
@@ -283,13 +213,13 @@ pub fn if_expression<F: Clone + Frame>(test_expr: Exp, if_expr: Exp, else_expr:
     )
 }
 
-pub fn init_array<F: Clone + Frame + PartialEq>(var: Option<Access<F>>, size_expr: Exp, is_pointer: Exp, init_expr: Exp, level: &Level<F>, in_closure: bool) -> Exp {
+pub fn init_array<F: Clone + Frame + PartialEq>(var: Option<Access<F>>, size_expr: Exp, is_pointer: Exp, init_expr: Exp, level: &Level<F>) -> Exp {
     // FIXME: it does many allocations for a 2D array.
     let temp = Temp::new();
     let result =
         if let Some(var) = var.clone() {
             let level = var.0.clone();
-            simple_var(var, &level, in_closure)
+            simple_var(var, &level)
         }
         else {
             Exp::Temp(temp)
@@ -335,44 +265,6 @@ pub fn num(number: i64) -> Exp {
     Const(number)
 }
 
-pub fn class_create<F: Frame + PartialEq>(var: Access<F>, data_layout: Exp, fields: Vec<Exp>, vtable_name: Label, in_closure: bool) -> Exp {
-    let level = var.0.clone();
-    let result = simple_var(var, &level, in_closure);
-
-    let mut sequence = Move(result.clone(), F::external_call("allocClass", vec![data_layout], true)).into();
-    sequence = Sequence(
-        Box::new(sequence),
-        Box::new(Move(Mem(Box::new(BinOp {
-            op: Plus,
-            left: Box::new(result.clone()),
-            right: Box::new(Const(VTABLE_OFFSET as i64 * F::WORD_SIZE)),
-        })), Exp::Name(vtable_name)).into())
-    ).into();
-    for (index, field) in fields.into_iter().enumerate() {
-        let index = index + CLASS_DATA_LAYOUT_SIZE;
-        let temp = Exp::Temp(Temp::new());
-        sequence = Sequence(
-            Box::new(sequence),
-            Box::new(Sequence(
-                // NOTE: the field is move into a temp first to avoid GC issues.
-                // The idea is that the object field's offset won't be computed and spilled before
-                // the field is computed. If the offset is spilled, it won't be updated by the GC
-                // in case of heap relocation because it's a derived pointer.
-                Box::new(Move(temp.clone(), field).into()),
-                Box::new(Move(Mem(Box::new(BinOp {
-                    op: Plus,
-                    left: Box::new(result.clone()),
-                    right: Box::new(Const(index as i64 * F::WORD_SIZE)),
-                })), temp).into())
-            ).into()),
-        ).into();
-    }
-    ExpSequence(
-        Box::new(sequence),
-        Box::new(result),
-    )
-}
-
 pub fn record_create<F: Frame>(data_layout: Exp, fields: Vec<Exp>) -> Exp {
     if fields.is_empty() {
         return unit();
@@ -442,22 +334,9 @@ pub fn relational_oper<F: Clone + Frame>(op: Operator, left: Exp, right: Exp, le
     )
 }
 
-pub fn simple_var<F: Clone + Frame + PartialEq>(access: Access<F>, level: &Level<F>, in_closure: bool) -> Exp {
-    let mut function_level = level;
-    let var_level = access.0;
+pub fn simple_var<F: Clone + Frame + PartialEq>(access: Access<F>, level: &Level<F>) -> Exp {
     let frame = level.current.borrow();
-    let mut var = Exp::Temp(F::fp());
-    // Add the offset of each parent frames (static link).
-    while function_level.current != var_level.current {
-        if in_closure {
-            panic!("Trying to access static link from inside a closure");
-        }
-
-        var = frame.exp(function_level.current.borrow().formals().last().expect("static link").clone(), var);
-        function_level = function_level.parent.as_ref().unwrap_or_else(|| panic!("function level should have a parent"));
-    }
-    var = frame.exp(access.1, var);
-    var
+    frame.exp(access.1, Exp::Temp(F::fp()))
 }
 
 pub fn string_equality<F: Frame>(oper: Operator, left: Exp, right: Exp) -> Exp {
@@ -573,23 +452,23 @@ fn to_ir_rel_op(op: Operator) -> RelationalOp {
 }
 
 pub struct Gen<F: Frame> {
-    fragments: Vec<Fragment<F>>,
+    ir: IR<F>,
 }
 
 impl<F:Frame> Gen<F> {
     pub fn new() -> Self {
         Self {
-            fragments: vec![],
+            ir: IR::new(),
         }
     }
 
-    pub fn get_result(self) -> Vec<Fragment<F>> {
-        self.fragments
+    pub fn get_result(self) -> IR<F> {
+        self.ir
     }
 
     pub fn proc_entry_exit(&mut self, level: &Level<F>, body: Exp, temp_map: TempMap, escaping_vars: Vec<i64>) {
         let body = Move(Exp::Temp(F::return_value()), body).into();
-        self.fragments.push(Fragment::Function {
+        self.ir.functions.insert(level.current.borrow().name().to_string(), Fragment::Function {
             body,
             escaping_vars,
             frame: level.current.clone(),
@@ -599,14 +478,7 @@ impl<F:Frame> Gen<F> {
 
     pub fn string_literal(&mut self, string: String) -> Exp {
         let label = Label::new();
-        self.fragments.push(Fragment::Str(label.clone(), string));
+        self.ir.data.push(Fragment::Str(label.clone(), string));
         Name(label)
     }
-
-    pub fn vtable(&mut self, class: Label, methods: Vec<Label>) {
-        self.fragments.push(Fragment::VTable {
-            class,
-            methods,
-        });
-    }
 }
diff --git a/tiger/src/lexer.rs b/tiger/src/lexer.rs
index 7bd7d1d..2edb2fe 100644
--- a/tiger/src/lexer.rs
+++ b/tiger/src/lexer.rs
@@ -174,27 +174,18 @@ impl<R: Read> Lexer<R> {
         let token =
             match ident.as_str() {
                 "array" => Array,
-                "break" => Break,
-                "class" => Class,
                 "do" => Do,
                 "else" => Else,
                 "end" => End,
-                "extends" => Extends,
-                "for" => For,
                 "function" => Function,
                 "if" => If,
                 "in" => In,
                 "let" => Let,
-                "method" => Method,
-                "new" => New,
                 "nil" => Nil,
                 "of" => Of,
-                "pure" => Pure,
                 "then" => Then,
-                "to" => To,
                 "type" => Type,
                 "var" => Var,
-                "while" => While,
                 _ => Ident(ident),
             };
         self.make_token(token, len)
diff --git a/tiger/src/lib.rs b/tiger/src/lib.rs
index def3d37..c57fc01 100644
--- a/tiger/src/lib.rs
+++ b/tiger/src/lib.rs
@@ -40,6 +40,7 @@ use std::ffi::CStr;
 use std::io::{Read, Write, stdin, stdout};
 use std::mem;
 use std::os::raw::{c_char, c_void};
+use std::process::exit;
 use std::ptr;
 
 use collector::{Layout, GARBAGE_COLLECTOR};
@@ -74,7 +75,7 @@ extern fn chr(num: i64) -> *const c_char {
 }
 
 #[no_mangle]
-extern fn getchar() -> *const c_char {
+extern fn getchar(continuation: *const c_void) {
     let stdin = stdin();
     let char = stdin.bytes().next().expect("next char").expect("read stdin") as char;
 
@@ -88,15 +89,9 @@ extern fn getchar() -> *const c_char {
         let string_ptr = string_ptr.offset(1);
         *string_ptr = 0;
     }
-    string
-}
-
-#[no_mangle]
-extern fn getcharP(continuation: *const c_void) {
-    let char = getchar();
     unsafe {
-        let function: fn(*const c_char) = mem::transmute(get_function_pointer(continuation));
-        function(char);
+        let function: fn(*const c_char, *const c_void) = mem::transmute(get_function_pointer(continuation));
+        function(string, continuation);
     }
 }
 
@@ -131,13 +126,6 @@ extern fn stringEqual(string1: *const c_char, string2: *const c_char) -> i64 {
     (cstring1 == cstring2) as i64
 }
 
-#[no_mangle]
-extern fn allocClass(data_layout: *const c_char) -> i64 {
-    GARBAGE_COLLECTOR.with(|collector| {
-        collector.borrow_mut().allocate(Layout::Class(data_layout))
-    })
-}
-
 #[no_mangle]
 extern fn allocRecord(data_layout: *const c_char) -> i64 {
     GARBAGE_COLLECTOR.with(|collector| {
@@ -153,24 +141,43 @@ extern fn initArray(length: usize, is_pointer: i64) -> i64 {
 }
 
 #[no_mangle]
-extern fn print(string: *const c_char) {
+extern fn print(string: *const c_char, continuation: *const c_void) {
     let cstring = unsafe { CStr::from_ptr(string_offset(string)) };
     if let Ok(string) = cstring.to_str() {
         print!("{}", string);
     }
     let _ = stdout().flush();
+    unsafe {
+        let function: fn(*const c_void) = mem::transmute(get_function_pointer(continuation));
+        function(continuation);
+    }
 }
 
 #[no_mangle]
-extern fn printP(string: *const c_char, continuation: *const c_void) {
-    print(string);
-    let function = get_function_pointer(continuation);
-    function();
+extern fn debug(string: *const c_char) {
+    let cstring = unsafe { CStr::from_ptr(string_offset(string)) };
+    if let Ok(string) = cstring.to_str() {
+        println!("{}", string);
+    }
+}
+
+#[no_mangle]
+extern fn debugInt(num: i32) {
+    println!("{}", num);
 }
 
 #[no_mangle]
-extern fn printi(num: i32) {
+extern fn printi(num: i32, continuation: *const c_void) {
     println!("{}", num);
+    unsafe {
+        let function: fn(*const c_void) = mem::transmute(get_function_pointer(continuation));
+        function(continuation);
+    }
+}
+
+#[no_mangle]
+extern fn tigerExit() {
+    exit(0);
 }
 
 // Get the pointer where the string starts, i.e. after the data layout.
diff --git a/tiger/src/log.rs b/tiger/src/log.rs
new file mode 100644
index 0000000..b5d483f
--- /dev/null
+++ b/tiger/src/log.rs
@@ -0,0 +1,26 @@
+#![allow(dead_code)]
+
+pub struct Logger {
+    indent: usize,
+}
+
+impl Logger {
+    pub fn new() -> Self {
+        Self {
+            indent: 0,
+        }
+    }
+
+    pub fn begin_scope(&mut self) {
+        self.indent += 4;
+    }
+
+    pub fn end_scope(&mut self) {
+        self.indent -= 4;
+    }
+
+    pub fn print(&self, msg: &str) {
+        let indent = " ".repeat(self.indent);
+        println!("{}{}", indent, msg);
+    }
+}
diff --git a/tiger/src/main.rs b/tiger/src/main.rs
index b3097ce..6ff00d2 100644
--- a/tiger/src/main.rs
+++ b/tiger/src/main.rs
@@ -20,6 +20,8 @@
  */
 
 /*
+ * TODO: do not stack allocate escaping variables anymore (since they're on the heap now)?
+ *
  * FIXME: array elements initialized to the same record (instead of allocating a record per
  * element).
  *
@@ -51,6 +53,8 @@ mod graph;
 mod ir;
 mod lexer;
 mod liveness;
+mod log;
+mod opt;
 mod parser;
 mod position;
 mod reg_alloc;
@@ -79,6 +83,7 @@ use escape::find_escapes;
 use frame::{Fragment, Frame};
 use frame::x86_64::X86_64;
 use lexer::Lexer;
+use opt::optimize;
 use parser::Parser;
 use reg_alloc::alloc;
 use rewriter::Rewriter;
@@ -115,7 +120,9 @@ fn drive(strings: Rc<Strings>, symbols: &mut Symbols<()>) -> Result<(), Error> {
         let mut env = Env::<X86_64>::new(&strings, escape_env);
         {
             let semantic_analyzer = SemanticAnalyzer::new(&mut env, symbols, Rc::clone(&strings));
-            let fragments = semantic_analyzer.analyze(ast)?;
+            let mut ir = semantic_analyzer.analyze(ast)?;
+
+            optimize(&mut ir);
 
             let mut asm_output_path = PathBuf::from(&filename);
             asm_output_path.set_extension("s");
@@ -133,9 +140,13 @@ fn drive(strings: Rc<Strings>, symbols: &mut Symbols<()>) -> Result<(), Error> {
             writeln!(file, "section .data")?;
             writeln!(file, "    align 2")?;
 
-            for fragment in &fragments {
+            /*for fragment in &fragments {
                 match *fragment {
                     Fragment::Function { .. } => (),
+                    Fragment::Str(ref label, ref string) => {*/
+            for fragment in &ir.data {
+                match *fragment {
+                    Fragment::Function { .. } => unreachable!(),
                     Fragment::Str(ref label, ref string) => {
                         // NOTE: creating a useless data layout here so that heap-allocated strings
                         // are accessed the same way as static strings.
@@ -146,16 +157,6 @@ fn drive(strings: Rc<Strings>, symbols: &mut Symbols<()>) -> Result<(), Error> {
                         }
                         writeln!(file, "db {}, 0", to_nasm(string))?;
                     },
-                    Fragment::VTable { ref class, ref methods } => {
-                        writeln!(file, "{}:", class)?;
-                        if !methods.is_empty() {
-                            let labels = methods.iter()
-                                .map(|label| label.to_string())
-                                .collect::<Vec<_>>()
-                                .join("\n    dq ");
-                            writeln!(file, "    dq {}", labels)?;
-                        }
-                    },
                 }
             }
 
@@ -163,7 +164,7 @@ fn drive(strings: Rc<Strings>, symbols: &mut Symbols<()>) -> Result<(), Error> {
 
             writeln!(file, "\nsection .text")?;
 
-            for fragment in fragments {
+            for (_, fragment) in ir.functions {
                 match fragment {
                     Fragment::Function { body, escaping_vars, frame, temp_map } => {
                         let mut frame = frame.borrow_mut();
@@ -193,8 +194,7 @@ fn drive(strings: Rc<Strings>, symbols: &mut Symbols<()>) -> Result<(), Error> {
                         }
                         writeln!(file, "    {}", subroutine.epilog)?;
                     },
-                    Fragment::Str(_, _) => (),
-                    Fragment::VTable { .. } => (),
+                    Fragment::Str(_, _)  => unreachable!(),
                 }
             }
 
diff --git a/tiger/src/opt.rs b/tiger/src/opt.rs
new file mode 100644
index 0000000..7f92d93
--- /dev/null
+++ b/tiger/src/opt.rs
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Boucher, Antoni <bouanto@zoho.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+use frame::Frame;
+use gen::IR;
+
+pub fn optimize<F: Frame>(ir: &mut IR<F>) {
+    let mut optimizer = Opt::new(ir);
+    optimizer.optimize();
+}
+
+struct Opt<'a, F: Frame> {
+    ir: &'a mut IR<F>,
+}
+
+impl<'a, F: Frame> Opt<'a, F> {
+    fn new(ir: &'a mut IR<F>) -> Self {
+        Self {
+            ir,
+        }
+    }
+
+    fn optimize(&mut self) {
+        let names: Vec<_> = self.ir.functions.keys()
+            .cloned()
+            .collect(); // TODO: remove collect and clone?
+        for func_name in names {
+            self.inline(&func_name);
+        }
+    }
+
+    fn inline(&mut self, _func_name: &str) {
+    }
+}
diff --git a/tiger/src/parser.rs b/tiger/src/parser.rs
index 06dac38..2753cd1 100644
--- a/tiger/src/parser.rs
+++ b/tiger/src/parser.rs
@@ -34,15 +34,12 @@ use std::result;
 
 use ast::{
     Declaration,
-    Declaration::ClassDeclaration,
     Declaration::VariableDeclaration,
     DeclarationWithPos,
     Expr,
     ExprWithPos,
     Field,
     FieldWithPos,
-    FuncDeclaration,
-    FuncDeclarationWithPos,
     Operator,
     RecordField,
     RecordFieldWithPos,
@@ -50,7 +47,6 @@ use ast::{
     TypeDec,
     TypeDecWithPos,
     TyWithPos,
-    dummy_var_expr,
 };
 use error::Error;
 use error::Error::UnexpectedToken;
@@ -111,6 +107,7 @@ macro_rules! fields {
 pub type Result<T> = result::Result<T, Error>;
 
 pub struct Parser<'a, R: Read> {
+    closure_index: usize,
     lexer: Lexer<R>,
     lookahead: Option<Result<Token>>,
     symbols: &'a mut Symbols<()>,
@@ -119,6 +116,7 @@ pub struct Parser<'a, R: Read> {
 impl<'a, R: Read> Parser<'a, R> {
     pub fn new(lexer: Lexer<R>, symbols: &'a mut Symbols<()>) -> Self {
         Parser {
+            closure_index: 0,
             lexer,
             lookahead: None,
             symbols,
@@ -168,11 +166,6 @@ impl<'a, R: Read> Parser<'a, R> {
         }, pos))
     }
 
-    fn break_(&mut self) -> Result<ExprWithPos> {
-        let pos = eat!(self, Break);
-        Ok(WithPos::new(Expr::Break, pos))
-    }
-
     fn call_args(&mut self) -> Result<(Vec<ExprWithPos>, Pos)> {
         eat!(self, OpenParen);
         let mut args = vec![];
@@ -221,45 +214,13 @@ impl<'a, R: Read> Parser<'a, R> {
                 OpenCurly => self.rec_create(WithPos::new(symbol, pos), pos),
                 _ => {
                     let var = WithPos::new(Expr::Variable(WithPos::new(symbol, pos)), pos);
-                    self.lvalue_or_assign(var)
+                    self.lvalue_or_calls(var)
                 }
             }
         }
     }
 
-    fn class_dec(&mut self) -> Result<DeclarationWithPos> {
-        let pos = eat!(self, Class);
-        let name;
-        let ident_pos = eat!(self, Ident, name);
-        let name = WithPos::new(self.symbols.symbol(&name), ident_pos);
-        eat!(self, Extends);
-        let parent_class;
-        let ident_pos = eat!(self, Ident, parent_class);
-        let parent_class = WithPos::new(self.symbols.symbol(&parent_class), ident_pos);
-        eat!(self, OpenCurly);
-
-        let mut declarations = vec![];
-        while let Method | Var = self.peek()?.token {
-            declarations.push(self.dec()?);
-        }
-
-        let end_pos = eat!(self, CloseCurly);
-        Ok(WithPos::new(ClassDeclaration {
-            declarations,
-            name,
-            parent_class,
-        }, pos.grow(end_pos)))
-    }
-
     fn closure(&mut self) -> Result<ExprWithPos> {
-        let pure =
-            if self.peek()?.token == Pure {
-                eat!(self, Pure);
-                true
-            }
-            else {
-                false
-            };
         let pos = eat!(self, Function);
         eat!(self, OpenParen);
         let params = fields!(self, CloseParen);
@@ -268,19 +229,18 @@ impl<'a, R: Read> Parser<'a, R> {
         eat!(self, Equal);
         let body = Box::new(self.expr()?);
         let pos = pos.grow(body.pos);
+        self.closure_index += 1;
         Ok(WithPos::new(Expr::Closure {
             body,
+            name: WithPos::new(self.symbols.symbol(&format!("__closure_{}", self.closure_index)), pos),
             params,
-            pure,
             result,
         }, pos))
     }
 
     fn dec(&mut self) -> Result<DeclarationWithPos> {
         match self.peek()?.token {
-            Class => self.class_dec(),
-            Pure | Function => self.fun_decs(Function),
-            Method => self.fun_decs(Method),
+            Function => self.fun_dec(Function),
             Type => self.ty_decs(),
             Var => self.var_dec(),
             _ => Err(self.unexpected_token("function, type or var")?),
@@ -306,29 +266,17 @@ impl<'a, R: Read> Parser<'a, R> {
         }, pos))
     }
 
-    fn field_exp_or_method_call(&mut self, var: ExprWithPos) -> Result<ExprWithPos> {
+    fn field_exp(&mut self, var: ExprWithPos) -> Result<ExprWithPos> {
         eat!(self, Dot);
         let name;
         let pos = eat!(self, Ident, name);
         let name = WithPos::new(self.symbols.symbol(&name), pos);
-        if self.peek()?.token == OpenParen {
-            let (args, end_pos) = self.call_args()?;
-            let call_pos = var.pos.grow(end_pos);
-            let method_call = WithPos::new(Expr::MethodCall {
-                args,
-                method: name,
-                this: Box::new(var),
-            }, call_pos);
-            self.lvalue(method_call)
-        }
-        else {
-            let var_pos = var.pos.grow(pos);
-            let var = WithPos::new(Expr::Field {
-                ident: name,
-                this: Box::new(var),
-            }, var_pos);
-            self.lvalue(var)
-        }
+        let var_pos = var.pos.grow(pos);
+        let var = WithPos::new(Expr::Field {
+            ident: name,
+            this: Box::new(var),
+        }, var_pos);
+        self.lvalue(var)
     }
 
     fn fields(&mut self) -> Result<Vec<FieldWithPos>> {
@@ -353,99 +301,7 @@ impl<'a, R: Read> Parser<'a, R> {
         }, pos))
     }
 
-    fn for_loop(&mut self) -> Result<ExprWithPos> {
-        let pos = eat!(self, For);
-        let var_name;
-        let var_pos = eat!(self, Ident, var_name);
-        let var = self.symbols.symbol(&var_name);
-        let iter_variable = WithPos::new(Expr::Variable(WithPos::new(var, var_pos)), var_pos);
-        eat!(self, ColonEqual);
-        let start = self.expr()?;
-        eat!(self, To);
-        let end = self.expr()?;
-        eat!(self, Do);
-        let body = self.expr()?;
-        // Convert for loop into while loop.
-        let start_symbol = self.symbols.symbol(&var_name);
-        let end_symbol = self.symbols.symbol(&format!("__{}_limit", var_name));
-        let declarations = vec![
-            WithPos::dummy(VariableDeclaration {
-                escape: false,
-                init: start,
-                name: start_symbol,
-                typ: None,
-            }),
-            WithPos::dummy(VariableDeclaration {
-                escape: false,
-                init: end,
-                name: end_symbol,
-                typ: None,
-            }),
-        ];
-        let body =
-            Expr::If {
-                else_: None,
-                test: Box::new(
-                    WithPos::dummy(Expr::Oper {
-                        left: Box::new(iter_variable.clone()),
-                        oper: WithPos::dummy(Operator::Le),
-                        right: Box::new(dummy_var_expr(end_symbol)),
-                    })
-                ),
-                then:
-                    Box::new(WithPos::new(Expr::While {
-                        body: Box::new(WithPos::dummy(Expr::Sequence(vec![
-                            body,
-                            WithPos::dummy(Expr::If {
-                                else_: Some(Box::new(WithPos::dummy(Expr::Break))),
-                                test:
-                                    Box::new(WithPos::dummy(Expr::Oper {
-                                        left: Box::new(iter_variable.clone()),
-                                        oper: WithPos::dummy(Operator::Lt),
-                                        right: Box::new(dummy_var_expr(end_symbol)),
-                                    })),
-                                then:
-                                    Box::new(WithPos::dummy(Expr::Assign {
-                                        expr: Box::new(WithPos::dummy(Expr::Oper {
-                                            left: Box::new(iter_variable.clone()),
-                                            oper: WithPos::dummy(Operator::Plus),
-                                            right: Box::new(WithPos::dummy(Expr::Int { value: 1 })),
-                                        })),
-                                        var: Box::new(iter_variable),
-                                    })),
-                            }),
-                        ]))),
-                        test: Box::new(WithPos::dummy(Expr::Int {
-                            value: 1,
-                        })),
-                    }, pos)),
-            };
-
-        Ok(WithPos::new(Expr::Let {
-            body: Box::new(WithPos::dummy(body)),
-            declarations,
-        }, pos))
-    }
-
-    fn fun_decs(&mut self, token: Tok) -> Result<DeclarationWithPos> {
-        let func = self.fun_dec(token.clone())?;
-        let pos = func.pos;
-        let mut functions = vec![func];
-        while self.peek()?.token == token {
-            functions.push(self.fun_dec(token.clone())?);
-        }
-        Ok(WithPos::new(Declaration::Function(functions), pos))
-    }
-
-    fn fun_dec(&mut self, token: Tok) -> Result<FuncDeclarationWithPos> {
-        let pure =
-            if self.peek()?.token == Pure {
-                eat!(self, Pure);
-                true
-            }
-            else {
-                false
-            };
+    fn fun_dec(&mut self, token: Tok) -> Result<DeclarationWithPos> {
         let tok = self.token()?;
         assert!(tok.token == token);
         let pos = tok.pos;
@@ -458,12 +314,17 @@ impl<'a, R: Read> Parser<'a, R> {
         let result = self.optional_type()?;
         eat!(self, Equal);
         let body = self.expr()?;
-        Ok(WithPos::new(FuncDeclaration {
-            body,
-            name,
-            params,
-            pure,
-            result,
+        let name_symbol = name.node;
+        Ok(WithPos::new(VariableDeclaration {
+            escape: false,
+            init: WithPos::new(Expr::Closure {
+                body: Box::new(body),
+                name,
+                params,
+                result,
+            }, pos),
+            name: name_symbol,
+            typ: None,
         }, pos))
     }
 
@@ -500,10 +361,10 @@ impl<'a, R: Read> Parser<'a, R> {
     fn let_expr(&mut self) -> Result<ExprWithPos> {
         let pos = eat!(self, Let);
         let mut declarations = vec![self.dec()?];
-        while let Class | Function | Pure | Type | Var = self.peek()?.token {
+        while let Function | Type | Var = self.peek()?.token {
             declarations.push(self.dec()?);
         }
-        eat!(self, In, "class, function, in, type, var".to_string());
+        eat!(self, In, "function, in, type, var".to_string());
         let expr = self.expr()?;
         let mut exprs = vec![expr];
         while let Semicolon = self.peek()?.token {
@@ -551,12 +412,12 @@ impl<'a, R: Read> Parser<'a, R> {
     fn lvalue(&mut self, var: ExprWithPos) -> Result<ExprWithPos> {
         match self.peek()?.token {
             OpenSquare => self.subscript(var),
-            Dot => self.field_exp_or_method_call(var),
+            Dot => self.field_exp(var),
             _ => Ok(var),
         }
     }
 
-    fn lvalue_or_assign(&mut self, var: ExprWithPos) -> Result<ExprWithPos> {
+    fn lvalue_or_calls(&mut self, var: ExprWithPos) -> Result<ExprWithPos> {
         let var = self.lvalue(var)?;
         let value =
             if let Of = self.peek()?.token {
@@ -576,18 +437,7 @@ impl<'a, R: Read> Parser<'a, R> {
             else {
                 var
             };
-        if let ColonEqual = self.peek()?.token {
-            eat!(self, ColonEqual);
-            let expr = Box::new(self.expr()?);
-            let pos = value.pos.grow(expr.pos);
-            Ok(WithPos::new(Expr::Assign {
-                expr,
-                var: Box::new(value),
-            }, pos))
-        }
-        else {
-            self.more_calls(value)
-        }
+        self.more_calls(value)
     }
 
     fn multiplicative_expr(&mut self) -> Result<ExprWithPos> {
@@ -610,16 +460,6 @@ impl<'a, R: Read> Parser<'a, R> {
         Ok(expr)
     }
 
-    fn new_object(&mut self) -> Result<ExprWithPos> {
-        let pos = eat!(self, New);
-        let class_name;
-        let end_pos = eat!(self, Ident, class_name);
-        let class_name = WithPos::new(self.symbols.symbol(&class_name), end_pos);
-        Ok(WithPos::new(Expr::New {
-            class_name,
-        }, pos.grow(end_pos)))
-    }
-
     fn nil(&mut self) -> Result<ExprWithPos> {
         let pos = eat!(self, Nil);
         Ok(WithPos::new(Expr::Nil, pos))
@@ -639,19 +479,15 @@ impl<'a, R: Read> Parser<'a, R> {
 
     fn primary_expr(&mut self) -> Result<ExprWithPos> {
         match self.peek()?.token {
-            Break => self.break_(),
-            For => self.for_loop(),
-            Function | Pure => self.closure(),
+            Function => self.closure(),
             If => self.if_then_else(),
             Ident(_) => self.call_expr_or_other(),
             Int(_) => self.int_lit(),
             Let => self.let_expr(),
-            New => self.new_object(),
             Nil => self.nil(),
             OpenParen => self.seq_exp(),
             Str(_) => self.string_lit(),
-            While => self.while_loop(),
-            _ => Err(self.unexpected_token("break, for, function, if, identifier, integer literal, let, nil, (, string literal, while")?),
+            _ => Err(self.unexpected_token("break, function, if, identifier, integer literal, let, nil, (, string literal, while")?),
         }
     }
 
@@ -858,17 +694,6 @@ impl<'a, R: Read> Parser<'a, R> {
         }, pos))
     }
 
-    fn while_loop(&mut self) -> Result<ExprWithPos> {
-        let pos = eat!(self, While);
-        let test = Box::new(self.expr()?);
-        eat!(self, Do);
-        let body = Box::new(self.expr()?);
-        Ok(WithPos::new(Expr::While {
-            body,
-            test,
-        }, pos))
-    }
-
     pub fn parse(&mut self) -> Result<ExprWithPos> {
         let main_expression = self.expr()?;
         match self.token() {
diff --git a/tiger/src/reg_alloc.rs b/tiger/src/reg_alloc.rs
index e6589b7..e4108f3 100644
--- a/tiger/src/reg_alloc.rs
+++ b/tiger/src/reg_alloc.rs
@@ -516,7 +516,7 @@ mod tests {
     use symbol::{Strings, Symbols};
     use temp::Temp;
 
-    fn get_intervals(filename: &str) -> (Vec<(Temp, Interval)>, HashMap<Temp, Interval>) {
+    fn get_intervals(filename: &str, mut skip_count: usize) -> (Vec<(Temp, Interval)>, HashMap<Temp, Interval>) {
         let strings = Rc::new(Strings::new());
         let file = BufReader::new(File::open(filename).expect("file open"));
         let mut symbols = Symbols::new(Rc::clone(&strings));
@@ -530,7 +530,11 @@ mod tests {
             let semantic_analyzer = SemanticAnalyzer::new(&mut env, &mut symbols, Rc::clone(&strings));
             let fragments = semantic_analyzer.analyze(ast).expect("semantic analyze");
 
-            for fragment in fragments {
+            for (_, fragment) in fragments.functions {
+                if skip_count > 0 {
+                    skip_count -= 1;
+                    continue;
+                }
                 match fragment {
                     Fragment::Function { body, escaping_vars, frame, temp_map } => {
                         let mut frame = frame.borrow_mut();
@@ -547,13 +551,16 @@ mod tests {
                         let instructions = generator.get_result();
                         let instructions = frame.proc_entry_exit2(instructions, escaping_vars);
 
+                        for (i, instruction) in instructions.iter().enumerate() {
+                            println!("{}. {}", i, instruction.to_string::<X86_64>());
+                        }
+
                         let mut allocator = Allocator::new::<X86_64>(instructions, temp_map);
                         let IntervalAnalysis { intervals, precolored_intervals, .. } = allocator.live_interval_analysis::<X86_64>();
 
                         return (intervals, precolored_intervals);
                     },
                     Fragment::Str(_, _) => (),
-                    Fragment::VTable { .. } => (),
                 }
             }
         }
@@ -564,37 +571,36 @@ mod tests {
     #[test]
     fn interval() {
         let files = vec![
-            "tests/hello.tig",
-            "tests/integers.tig",
-            "tests/conditions.tig",
+            ("tests/hello.tig", 0),
+            ("tests/integers.tig", 2),
+            ("tests/conditions.tig", 4),
         ];
 
         let mut expected_intervals = HashMap::new();
         let mut expected_precolored_intervals = HashMap::new();
 
         let mut intervals = HashMap::new();
-        intervals.insert(29, vec![(12, 12), (23, usize::MAX)]);
-        intervals.insert(30, vec![(8, 9), (23, usize::MAX)]);
-        intervals.insert(31, vec![(13, 14), (23, usize::MAX)]);
+        intervals.insert(31, vec![(10, 11), (20, usize::MAX)]);
+        intervals.insert(23, vec![(6, 16), (20, usize::MAX)]);
         expected_intervals.insert("tests/hello.tig", intervals);
         let mut intervals = HashMap::new();
         intervals.insert(2, vec![(0, usize::MAX)]);
         expected_precolored_intervals.insert("tests/hello.tig", intervals);
 
         let mut intervals = HashMap::new();
-        intervals.insert(66, vec![(20, 21), (83, usize::MAX)]);
-        intervals.insert(65, vec![(21, 23), (83, usize::MAX)]);
+        intervals.insert(134, vec![(61, 63), (119, usize::MAX)]);
+        intervals.insert(129, vec![(46, 47), (119, usize::MAX)]);
         expected_intervals.insert("tests/integers.tig", intervals);
 
         let mut intervals = HashMap::new();
-        intervals.insert(106, vec![(19, 20), (23, 26), (203, usize::MAX)]);
+        intervals.insert(179, vec![(46, 47), (50, 52), (174, usize::MAX)]);
         expected_intervals.insert("tests/conditions.tig", intervals);
         let mut intervals = HashMap::new();
         intervals.insert(2, vec![(0, usize::MAX)]);
         expected_precolored_intervals.insert("tests/conditions.tig", intervals);
 
-        for filename in files {
-            let (intervals, precolored_intervals) = get_intervals(filename);
+        for (filename, skip_count) in files {
+            let (intervals, precolored_intervals) = get_intervals(filename, skip_count);
             let intervals: HashMap<_, _> = intervals.into_iter().collect();
 
             for (&temp, expected_interval) in &expected_intervals[filename] {
diff --git a/tiger/src/rewriter.rs b/tiger/src/rewriter.rs
index ceecb93..84e1c09 100644
--- a/tiger/src/rewriter.rs
+++ b/tiger/src/rewriter.rs
@@ -50,13 +50,6 @@ impl<'a> Rewriter<'a> {
                     typ,
                 }, pos)
             },
-            Expr::Assign { expr, var } => {
-                WithPos::new(Expr::Assign {
-                    expr: Box::new(self.rewrite(*expr)),
-                    var: Box::new(self.rewrite(*var)),
-                }, pos)
-            },
-            Expr::Break => WithPos::new(Expr::Break, pos),
             Expr::Call { args, function } => {
                 let mut new_args = vec![];
                 let mut declarations = vec![];
@@ -83,11 +76,11 @@ impl<'a> Rewriter<'a> {
                     add_declarations(call, declarations, pos)
                 }
             },
-            Expr::Closure { body, params, pure, result } => {
+            Expr::Closure { body, name, params, result } => {
                 WithPos::new(Expr::Closure {
                     body: Box::new(self.rewrite(*body)),
+                    name,
                     params,
-                    pure,
                     result,
                 }, pos)
             },
@@ -108,11 +101,6 @@ impl<'a> Rewriter<'a> {
                     this: Box::new(self.rewrite(*this)),
                 }, pos)
             },
-            Expr::FunctionPointer { label } => {
-                WithPos::new(Expr::FunctionPointer {
-                    label,
-                }, pos)
-            },
             Expr::FunctionPointerCall { args, closure_name, function } => {
                 let mut new_args = vec![];
                 let mut declarations = vec![];
@@ -175,33 +163,6 @@ impl<'a> Rewriter<'a> {
                     declarations: new_declarations,
                 }, pos)
             },
-            Expr::MethodCall { args, method, this } => {
-                let mut new_args = vec![];
-                let mut declarations = vec![];
-                for arg in args {
-                    if can_extract(&arg) {
-                        let (name, declaration) = self.extract(arg);
-                        declarations.push(WithPos::new(declaration, pos));
-                        new_args.push(variable(name, pos));
-                    }
-                    else {
-                        new_args.push(self.rewrite(arg));
-                    }
-                }
-                let call = WithPos::new(Expr::MethodCall {
-                    args: new_args,
-                    method,
-                    this: Box::new(self.rewrite(*this)),
-                }, pos);
-
-                if declarations.is_empty() {
-                    call
-                }
-                else {
-                    add_declarations(call, declarations, pos)
-                }
-            },
-            Expr::New { class_name } => WithPos::new(Expr::New { class_name }, pos),
             Expr::Nil => WithPos::new(Expr::Nil, pos),
             Expr::Oper { left, right, oper } => {
                 let mut declarations = vec![];
@@ -281,31 +242,12 @@ impl<'a> Rewriter<'a> {
                 }, pos)
             },
             Expr::Variable(var) => WithPos::new(Expr::Variable(var), pos),
-            Expr::While { body, test } => {
-                // TODO: extract.
-                WithPos::new(Expr::While {
-                    body: Box::new(self.rewrite(*body)),
-                    test: Box::new(self.rewrite(*test)),
-                }, pos)
-            },
         }
     }
 
     fn rewrite_dec(&mut self, mut declaration: DeclarationWithPos) -> DeclarationWithPos {
         declaration.node =
             match declaration.node {
-                Declaration::ClassDeclaration { declarations, name, parent_class } => {
-                    let declarations =
-                        declarations
-                            .into_iter()
-                            .map(|declaration| self.rewrite_dec(declaration))
-                            .collect();
-                    Declaration::ClassDeclaration {
-                        declarations,
-                        name,
-                        parent_class,
-                    }
-                },
                 Declaration::Function(functions) => {
                     let mut new_functions = vec![];
                     for mut function in functions {
@@ -350,7 +292,7 @@ fn add_declarations(body: ExprWithPos, declarations: Vec<DeclarationWithPos>, po
 
 fn can_extract(expr: &ExprWithPos) -> bool {
     match expr.node {
-        Expr::Nil => false,
+        Expr::Nil | Expr::Variable(_) => false,
         _ => true,
     }
 }
diff --git a/tiger/src/semant.rs b/tiger/src/semant.rs
index 5156ea1..0907bc8 100644
--- a/tiger/src/semant.rs
+++ b/tiger/src/semant.rs
@@ -19,8 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-use std::cmp::Ordering;
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeSet, HashSet};
 use std::fmt::Debug;
 use std::mem;
 use std::rc::Rc;
@@ -30,6 +29,7 @@ use ast::{
     DeclarationWithPos,
     Expr,
     ExprWithPos,
+    Field,
     FieldWithPos,
     FuncDeclaration,
     Operator,
@@ -40,42 +40,35 @@ use ast::{
     TypeDecWithPos,
     TyWithPos,
 };
-use env::{Env, Entry};
+use env::{ClosureField, Env, Entry};
 use error::{Error, Result};
-use frame::{Fragment, Frame, Memory};
+use frame::{Frame, Memory};
 use gen;
 use gen::{
     Gen,
+    IR,
     Level,
     array_subscript,
     binary_oper,
-    class_create,
     field_access,
-    function_call,
     function_pointer_call,
-    goto,
     if_expression,
     init_array,
-    method_call,
     num,
     record_create,
     relational_oper,
     simple_var,
     string_equality,
-    unit,
     var_dec,
     var_decs,
-    while_loop,
 };
 use ir::{Exp, Statement, _Statement};
+use log::Logger;
 use position::{Pos, WithPos};
 use self::AddError::*;
 use symbol::{Strings, Symbol, Symbols, SymbolWithPos};
 use temp::{Label, TempMap};
 use types::{
-    ClassField,
-    ClassMethod,
-    FunctionType,
     Type,
     Unique,
 };
@@ -83,8 +76,6 @@ use visitor::Visitor;
 
 const CLOSURE_PARAM: &str = "__closure_param";
 const CLOSURE_FIELD: &str = "function_pointer";
-// Offset 2, because offset 0 is the object type (class) and offset 1 is the data layout.
-pub const VTABLE_OFFSET: usize = 2;
 
 #[derive(PartialEq)]
 enum AddError {
@@ -98,11 +89,6 @@ pub struct ExpTy {
     pub ty: Type,
 }
 
-pub enum FieldType {
-    Class,
-    Record,
-}
-
 const EXP_TYPE_ERROR: ExpTy =
     ExpTy {
         exp: Exp::Error,
@@ -113,35 +99,33 @@ pub struct SemanticAnalyzer<'a, F: Clone + Frame + 'a> {
     closure_index: usize,
     env: &'a mut Env<F>,
     errors: Vec<Error>,
-    escaping_vars: Vec<i64>,
+    escaping_vars: Vec<Vec<ClosureField>>,
+    escaping_var_locations: Vec<i64>,
     gen: Gen<F>,
-    in_closure: bool,
     in_loop: bool,
-    in_pure_fun: bool,
-    methods_level: HashMap<(Symbol, Symbol), Level<F>>,
-    self_symbol: Symbol,
     strings: Rc<Strings>,
     symbols: &'a mut Symbols<()>,
     temp_map: TempMap,
+
+    #[allow(dead_code)]
+    logger: Logger,
 }
 
 impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
     pub fn new(env: &'a mut Env<F>, symbols: &'a mut Symbols<()>, strings: Rc<Strings>) -> Self {
-        let self_symbol = symbols.symbol("self");
         SemanticAnalyzer {
             closure_index: 0,
             env,
             errors: vec![],
             escaping_vars: vec![],
+            escaping_var_locations: vec![],
             gen: Gen::new(),
-            in_closure: false,
             in_loop: false,
-            in_pure_fun: false,
-            methods_level: HashMap::new(),
-            self_symbol,
             symbols,
             strings,
             temp_map: TempMap::new(),
+
+            logger: Logger::new(),
         }
     }
 
@@ -149,7 +133,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         self.errors.push(error);
     }
 
-    pub fn analyze(mut self, expr: ExprWithPos) -> Result<Vec<Fragment<F>>> {
+    pub fn analyze(mut self, expr: ExprWithPos) -> Result<IR<F>> {
         let main_symbol = self.symbols.symbol("main");
         let pos = expr.pos;
         let body = WithPos::new(
@@ -162,7 +146,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 body,
                 name: WithPos::dummy(main_symbol),
                 params: vec![],
-                pure: false,
                 result,
             }, pos)
         ]), pos), &gen::outermost(), None);
@@ -222,52 +205,58 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         }
     }
 
-    fn check_function_types(&mut self, expected: &FunctionType, unexpected: &FunctionType, pos: Pos) {
-        if expected != unexpected {
-            self.add_error(Error::FunctionType {
-                expected: expected.clone(),
-                pos,
-                unexpected: unexpected.clone(),
-            });
+    fn compatible_types(&mut self, expected: &Type, unexpected: &Type) -> bool {
+        let expected = self.actual_ty(expected);
+        let unexpected = self.actual_ty(unexpected);
+        if expected != unexpected && expected != Type::Error && unexpected != Type::Error {
+            if let Type::Record { .. } = expected {
+                if unexpected == Type::Nil {
+                    return true;
+                }
+            }
+
+            if let (&Type::Function { parameters: ref left_parameters, return_type: ref left_return_type },
+                &Type::Closure { parameters: ref right_parameters, return_type: ref right_return_type }) =
+                (&expected, &unexpected)
+            {
+                let mut types_match = true;
+                if left_parameters.len() != right_parameters.len() {
+                    types_match = false;
+                }
+                for (left_param, right_param) in left_parameters.iter().zip(right_parameters) {
+                    if !self.compatible_types(left_param, right_param) {
+                        types_match = false;
+                    }
+                }
+                if !self.compatible_types(left_return_type, right_return_type) {
+                    types_match = false;
+                }
+
+                return types_match;
+            }
+            return false;
         }
+
+        true
     }
 
     fn check_types(&mut self, expected: &Type, unexpected: &Type, pos: Pos) {
         let expected = self.actual_ty(expected);
         let unexpected = self.actual_ty(unexpected);
         if expected != unexpected && expected != Type::Error && unexpected != Type::Error {
-            if let Type::Class { .. } | Type::Record { .. } = expected {
+            if let Type::Record { .. } = expected {
                 if unexpected == Type::Nil {
                     return;
                 }
             }
 
-            if let Type::Class { name: parent_class, .. } = expected {
-                if let Type::Class { name, .. } = unexpected {
-                    let mut current_class = name;
-                    loop {
-                        if current_class == parent_class {
-                            // NOTE: the expected type is a parent class.
-                            return;
-                        }
-                        let class = self.get_type(&WithPos::dummy(current_class), DontAddError);
-                        if let Type::Class { parent_class, .. } = class {
-                            if let Some(parent_class) = parent_class {
-                                current_class = parent_class.node;
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                    }
-                }
+            if !self.compatible_types(&expected, &unexpected) {
+                self.add_error(Error::Type {
+                    expected,
+                    pos,
+                    unexpected,
+                });
             }
-
-            self.add_error(Error::Type {
-                expected,
-                pos,
-                unexpected,
-            });
         }
     }
 
@@ -311,200 +300,31 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         -> Option<Statement>
     {
         match declaration.node {
-            Declaration::ClassDeclaration { ref declarations, ref name, ref parent_class } => {
-                struct Method<F> {
-                    body: ExprWithPos,
-                    level: Level<F>,
-                    param_names: Vec<Symbol>,
-                    param_types: Vec<Type>,
-                    return_type: Type,
-                }
-
-                let empty_class_type = Type::Class {
-                    data_layout: String::new(),
-                    fields: vec![],
-                    methods: vec![],
-                    name: name.node,
-                    parent_class: Some(parent_class.clone()),
-                    unique: Unique::new(),
-                    vtable_name: Label::new(),
-                };
-                self.env.enter_type(name.node, empty_class_type);
-
-                let old_escaping_vars = mem::take(&mut self.escaping_vars);
-                let old_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-
-                let mut pending_methods = vec![];
-                let parent_type = self.get_type(parent_class, AddError);
-                match parent_type {
-                    Type::Class { .. } | Type::Error => (),
-                    _ => {
-                        self.add_error(Error::NotAClass {
-                            pos: parent_class.pos,
-                            typ: parent_type,
-                        });
-                    },
-                }
-                let (mut fields, mut data_layout, parent_methods) = self.parent_members(parent_class);
-                let mut methods = vec![];
-                for declaration in declarations {
-                    match declaration.node {
-                        Declaration::Function(ref functions) => {
-                            for function in functions {
-                                let params = &function.node.params;
-                                let mut param_names = vec![];
-                                let mut param_types = vec![];
-                                let mut param_set = HashSet::new();
-                                for param in params {
-                                    param_types.push(self.get_type(&param.node.typ, AddError));
-                                    param_names.push(param.node.name);
-                                    if !param_set.insert(param.node.name) {
-                                        self.duplicate_param(param);
-                                    }
-                                }
-                                let return_type =
-                                    if let Some(ref result) = function.node.result {
-                                        self.get_type(result, AddError)
-                                    }
-                                    else {
-                                        Type::Unit
-                                    };
-
-                                let mut formals: Vec<_> = params.iter()
-                                    .map(|param| self.env.look_escape(param.node.name))
-                                    .collect();
-                                formals.insert(0, true); // NOTE: self implicit parameter.
-                                let func_name = function.node.name.node;
-                                let label = self.method_label(name.node, func_name);
-                                let level = Level::new(parent_level, label.clone(), formals);
-                                self.methods_level.insert((name.node, func_name), level.clone());
-                                methods.push(ClassMethod {
-                                    class_name: name.node,
-                                    label,
-                                    name: function.node.name.clone(),
-                                    typ: FunctionType {
-                                        param_types: param_types.clone(),
-                                        return_type: return_type.clone(),
-                                    },
-                                });
-
-                                pending_methods.push(Method {
-                                    body: function.node.body.clone(),
-                                    level,
-                                    param_names,
-                                    param_types,
-                                    return_type,
-                                });
-                            }
-                        },
-                        Declaration::VariableDeclaration { ref init, name, ref typ, .. } => {
-                            let exp = self.trans_exp(init, parent_level, done_label.clone(), true);
-                            let is_pointer =
-                                match exp.ty {
-                                    Type::Name(ref symbol, None) if symbol.node == name =>
-                                        true,
-                                    _ => self.actual_ty(&exp.ty).is_pointer(),
-                                };
-                            let typ =
-                                if let Some(ref typ) = *typ {
-                                    let typ = self.get_type(typ, AddError);
-                                    self.check_types(&typ, &exp.ty, init.pos);
-                                    typ
-                                }
-                                else {
-                                    exp.ty
-                                };
-                            if is_pointer {
-                                data_layout.push('p')
-                            }
-                            else {
-                                data_layout.push('n')
-                            }
-                            fields.push(ClassField {
-                                name,
-                                typ,
-                                value: init.clone(),
-                            });
-                        },
-                        _ => unreachable!("cannot get that kind of declaration in a class"),
-                    }
-                }
-                let class_name = self.strings.get(name.node).expect("string get");
-                let vtable_name = Label::with_name(&format!("__vtable_{}", class_name));
-                let methods = self.inherit_methods(parent_methods, &methods);
-                let class_type = Type::Class {
-                    data_layout,
-                    fields,
-                    methods: methods.clone(),
-                    name: name.node,
-                    parent_class: Some(parent_class.clone()),
-                    unique: Unique::new(),
-                    vtable_name: vtable_name.clone(),
-                };
-                self.env.replace_type(name.node, class_type.clone());
-
-                for method in pending_methods {
-                    let body = &method.body;
-                    self.env.begin_scope();
-                    let mut formals = method.level.formals().into_iter();
-                    self.env.enter_var(self.self_symbol, Entry::Var {
-                        access: formals.next().expect("self parameter").clone(),
-                        typ: class_type.clone(),
-                    });
-                    let fields =
-                        match class_type {
-                            Type::Class { ref fields, .. } => fields,
-                            _ => unreachable!(),
-                        };
-                    for field in fields {
-                        self.env.enter_var(field.name, Entry::ClassField { class: class_type.clone() });
-                    }
-                    for ((param, name), access) in method.param_types.into_iter().zip(method.param_names).zip(formals) {
-                        self.env.enter_var(name, Entry::Var { access, typ: param });
-                    }
-                    let exp = self.trans_exp(body, &method.level, done_label.clone(), true);
-                    self.check_types(&method.return_type, &exp.ty, body.pos);
-                    let current_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-                    let escaping_vars = mem::take(&mut self.escaping_vars);
-                    self.gen.proc_entry_exit(&method.level, exp.exp, current_temp_map, escaping_vars);
-                    self.env.end_scope();
-                }
-
-                let method_labels: Vec<_> = methods.iter()
-                    .map(|method| method.label.clone())
-                    .collect();
-                self.gen.vtable(vtable_name, method_labels);
-
-                self.escaping_vars = old_escaping_vars;
-                self.temp_map = old_temp_map;
-
-                None
-            },
             Declaration::Function(ref declarations) => {
                 let old_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-                let old_escaping_vars = mem::take(&mut self.escaping_vars);
+                let old_escaping_vars = mem::take(&mut self.escaping_var_locations);
                 let mut levels = vec![];
-                for &WithPos { node: FuncDeclaration { ref body, ref name, ref params, pure, ref result, .. }, .. } in declarations {
-                    let func_name = name.node;
+                for &WithPos { node: FuncDeclaration { ref name, ref params, ref result, .. }, .. } in declarations {
+                    let func_symbol = name.node;
+                    let func_name = self.strings.get(func_symbol).expect("string get");
                     let formals = params.iter()
                         .map(|param| self.env.look_escape(param.node.name))
                         .collect();
-                    let level = Level::new(parent_level, Label::with_name(&self.strings.get(func_name).expect("string get")), formals);
+                    let level = Level::new(parent_level, Label::with_name(&func_name), formals);
                     let result_type =
                         if let Some(ref result) = *result {
                             self.get_type(result, AddError)
                         }
-                        else if pure {
-                            Type::Answer
-                        }
                         else {
-                            Type::Unit
+                            Type::Answer
                         };
                     // TODO: error when name already exist?
                     let mut param_names = vec![];
                     let mut parameters = vec![];
+                    let mut param_type_symbols = vec![];
                     let mut param_set = HashSet::new();
                     for param in params {
+                        param_type_symbols.push(param.node.typ.clone());
                         parameters.push(self.get_type(&param.node.typ, AddError));
                         param_names.push(param.node.name);
                         if !param_set.insert(param.node.name) {
@@ -513,53 +333,58 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     }
                     levels.push(level.clone());
 
-                    let env_fields = find_closure_environment(body, self.env, level.clone());
-
-                    self.env.enter_var(func_name, Entry::Fun {
-                        access_outside_vars: !env_fields.is_empty(),
+                    self.env.enter_var(func_symbol, Entry::Fun {
                         external: false,
-                        label: Label::with_name(&self.strings.get(func_name).expect("strings get")),
-                        level,
+                        label: Label::with_name(&func_name),
                         parameters,
-                        pure,
+                        param_type_symbols,
                         result: result_type.clone(),
+                        result_symbol: result.clone(),
                     });
                 }
 
-                let old_in_pure_fun = self.in_pure_fun;
-                for (&WithPos { node: FuncDeclaration { ref params, ref body, pure, ref result, .. }, .. }, level) in
+                for (&WithPos { node: FuncDeclaration { ref params, ref body, ref result, .. }, .. }, level) in
                     declarations.iter().zip(&levels)
                 {
-                    self.in_pure_fun = pure;
                     let result_type =
                         if let Some(ref result) = *result {
                             self.get_type(result, DontAddError)
                         }
-                        else if pure {
-                            Type::Answer
-                        }
                         else {
-                            Type::Unit
+                            Type::Answer
                         };
                     let mut param_names = vec![];
                     let mut parameters = vec![];
+                    self.escaping_vars.push(vec![]);
                     for param in params {
-                        parameters.push(self.get_type(&param.node.typ, DontAddError));
+                        let param_type = self.get_type(&param.node.typ, DontAddError);
+                        if self.env.look_escape(param.node.name) {
+                            self.escaping_vars.last_mut().expect("scope")
+                                .push(ClosureField {
+                                    ident: param.node.name,
+                                    typ: param_type.clone(),
+                                });
+                        }
+                        parameters.push(param_type);
                         param_names.push(param.node.name);
                     }
                     self.env.begin_scope();
                     for ((param, name), access) in parameters.into_iter().zip(param_names).zip(level.formals().into_iter()) {
+                        if type_is_collectable(&param) {
+                            self.temp_map.insert::<F>(&access.1);
+                        }
                         self.env.enter_var(name, Entry::Var { access, typ: param });
                     }
+
                     let exp = self.trans_exp(body, level, done_label.clone(), true);
                     self.check_types(&result_type, &exp.ty, body.pos);
                     let current_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-                    let escaping_vars = mem::take(&mut self.escaping_vars);
-                    self.gen.proc_entry_exit(level, exp.exp, current_temp_map, escaping_vars);
+                    let escaping_var_locations = mem::take(&mut self.escaping_var_locations);
+                    self.gen.proc_entry_exit(level, exp.exp, current_temp_map, escaping_var_locations);
                     self.env.end_scope();
+                    self.escaping_vars.pop();
                 }
-                self.in_pure_fun = old_in_pure_fun;
-                self.escaping_vars = old_escaping_vars;
+                self.escaping_var_locations = old_escaping_vars;
                 self.temp_map = old_temp_map;
                 None
             },
@@ -576,13 +401,41 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 None
             },
             Declaration::VariableDeclaration { ref init, name, ref typ, .. } => {
+                let closure_type =
+                    if let Expr::Closure { ref params, ref result, .. } = init.node {
+                        let return_type =
+                            if let Some(ref result) = *result {
+                                self.get_type(result, AddError)
+                            }
+                            else {
+                                Type::Answer
+                            };
+                        let mut parameters = vec![];
+                        for param in params {
+                            parameters.push(self.get_type(&param.node.typ, DontAddError));
+                        }
+                        Some(Type::Closure {
+                            parameters,
+                            return_type: Box::new(return_type),
+                        })
+                    }
+                    else {
+                        None
+                    };
+                let mut access = gen::alloc_local(parent_level, false);
+                if let Some(ref typ) = closure_type {
+                    access = gen::alloc_local(parent_level, true);
+                    self.env.enter_var(name, Entry::Var { access: access.clone(), typ: typ.clone() });
+                }
                 let exp = self.trans_exp(init, parent_level, done_label, true);
-                let is_collectable = type_is_collectable(&exp.ty);
                 let escape = self.env.look_escape(name);
-                let access = gen::alloc_local(parent_level, escape || is_collectable); // TODO: check if this is necessary.
+                let is_collectable = type_is_collectable(&exp.ty);
+                if closure_type.is_none() {
+                    access = gen::alloc_local(parent_level, escape || is_collectable); // TODO: check if this is necessary.
+                }
                 if escape {
                     if let Some(stack_var) = access.1.as_stack() {
-                        self.escaping_vars.push(stack_var);
+                        self.escaping_var_locations.push(stack_var);
                     }
                 }
                 if is_collectable {
@@ -595,8 +448,17 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     self.add_error(Error::RecordType { pos: declaration.pos });
                     return None;
                 }
+                if escape {
+                    self.escaping_vars.last_mut().expect("scope")
+                        .push(ClosureField {
+                            ident: name,
+                            typ: exp.ty.clone(),
+                        });
+                }
                 let var = var_dec(&access, exp.exp);
-                self.env.enter_var(name, Entry::Var { access, typ: exp.ty });
+                if closure_type.is_none() {
+                    self.env.enter_var(name, Entry::Var { access, typ: exp.ty });
+                }
                 Some(var)
             },
         }
@@ -615,7 +477,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                         let access = gen::alloc_local(level, true);
                         self.temp_map.insert::<F>(&access.1);
                         if let Some(stack_var) = access.1.as_stack() {
-                            self.escaping_vars.push(stack_var);
+                            self.escaping_var_locations.push(stack_var);
                         }
                         Some(access)
                     }
@@ -636,101 +498,54 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 self.check_types(inner_type, &init_expr.ty, init.pos);
                 let is_pointer = self.array_contains_pointer(&ty);
                 let is_pointer = num(is_pointer as i64);
-                let exp = init_array::<F>(var, size_expr.exp, is_pointer, init_expr.exp, level, self.in_closure);
+                let exp = init_array::<F>(var, size_expr.exp, is_pointer, init_expr.exp, level);
                 ExpTy {
                     exp,
                     ty,
                 }
             },
-            Expr::Assign { ref expr, ref var } => {
-                if self.in_pure_fun {
-                    self.add_error(Error::CannotAssignInPureFun {
-                        pos,
-                    });
-                    return EXP_TYPE_ERROR;
-                }
-                match var.node {
-                    Expr::Field { .. } | Expr::Subscript { .. } | Expr::Variable(_) => (),
-                    _ => self.add_error(Error::Assign {
-                        pos: var.pos,
-                    }),
-                }
-                let var = self.trans_exp(var, level, done_label.clone(), true);
-                let expr_expr = self.trans_exp(expr, level, done_label, true);
-                self.check_types(&var.ty, &expr_expr.ty, expr.pos);
-                ExpTy {
-                    exp: Exp::ExpSequence(Box::new(_Statement::Move(var.exp, expr_expr.exp).into()), Box::new(unit())),
-                    ty: Type::Unit,
-                }
-            },
-            Expr::Break => {
-                if !self.in_loop {
-                    self.add_error(Error::BreakOutsideLoop {
-                        pos: expr.pos,
-                    });
-                    return EXP_TYPE_ERROR;
-                }
-                ExpTy {
-                    exp: goto(done_label.expect("break should be in while loop")),
-                    ty: Type::Unit,
-                }
-            },
             Expr::Call { ref args, ref function } => {
-                match function.node {
-                    Expr::Variable(ref func) => {
-                        match self.env.look_var(func.node).cloned() { // TODO: remove this clone.
-                            Some(Entry::Fun { external, ref label, ref parameters, ref result, level: ref current_level, pure, .. }) => {
-                                if self.in_pure_fun && !pure {
-                                    self.add_error(Error::CannotCallImpureFun {
-                                        pos,
-                                    });
-                                }
+                if let Expr::Variable(ref func) = function.node {
+                    match self.env.look_var(func.node).cloned() { // TODO: remove this clone.
+                        Some(Entry::Fun { external, ref label, ref parameters, ref result, .. }) => {
+                            if parameters.len() != args.len() {
+                                self.add_error(Error::InvalidNumberOfParams {
+                                    actual: args.len(),
+                                    expected: parameters.len(),
+                                    pos,
+                                });
+                            }
 
-                                let mut expr_args = vec![];
-                                if parameters.len() != args.len() {
-                                    self.add_error(Error::InvalidNumberOfParams {
-                                        actual: args.len(),
-                                        expected: parameters.len(),
-                                        pos,
-                                    });
-                                }
-                                for (arg, param) in args.iter().zip(parameters) {
-                                    let exp = self.trans_exp(arg, level, done_label.clone(), true);
-                                    self.check_types(param, &exp.ty, arg.pos);
-                                    expr_args.push(exp.exp);
-                                }
-                                let collectable_return_type = type_is_collectable(result);
-                                let exp =
-                                    if external {
-                                        F::external_call(&label.to_name(), expr_args, collectable_return_type)
-                                    }
-                                    else {
-                                        function_call(label, expr_args, level, current_level, collectable_return_type, self.in_closure)
-                                    };
-                                ExpTy {
-                                    exp,
+                            let mut expr_args = vec![];
+                            for (arg, param) in args.iter().zip(parameters) {
+                                let exp = self.trans_exp(arg, level, done_label.clone(), true);
+                                self.check_types(param, &exp.ty, arg.pos);
+                                expr_args.push(exp.exp);
+                            }
+
+                            let collectable_return_type = type_is_collectable(result);
+
+                            if external {
+                                return ExpTy {
+                                    exp: F::external_call(&label.to_name(), expr_args, collectable_return_type),
                                     ty: self.actual_ty(result),
-                                }
-                            },
-                            Some(_) => self.closure_call(function, args, level, done_label),
-                            None => self.undefined_function(func.node, func.pos),
-                        }
-                    },
-                    _ => self.closure_call(function, args, level, done_label),
+                                };
+                            }
+                        },
+                        None => return self.undefined_function(func.node, func.pos),
+                        _ => (),
+                    }
                 }
+                self.closure_call(function, args, level, done_label)
             },
-            Expr::Closure { ref body, ref params, pure, ref result } => {
+            Expr::Closure { ref body, ref name, ref params, ref result } => {
                 let mut data_layout = String::new();
                 data_layout.push('n'); // First field is the function pointer, which is not heap-allocated.
 
-                let name = format!("__closure_{}", self.closure_index);
-                let func_name = self.symbols.symbol(&name);
+                let func_name = name.node;
                 let formals: Vec<_> = params.iter()
                     .map(|param| self.env.look_escape(param.node.name))
                     .collect();
-                // NOTE: do not push a formal for the closure (environment), because Level::new()
-                // already push a formal for the static link that we can reuse since closures don't
-                // have static link.
                 let func_level = Level::new(level, Label::with_name(&self.strings.get(func_name).expect("string get")), formals);
                 let closure_level = func_level.formals().last().expect("closure access").0.clone();
 
@@ -753,6 +568,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 let data_layout = self.gen.string_literal(data_layout);
 
                 let closure_symbol = self.symbols.symbol(&format!("Closure{}", self.closure_index));
+                self.closure_index += 1;
                 let record_type = Type::Record {
                     data_layout,
                     name: closure_symbol,
@@ -766,7 +582,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                         body: *body.clone(),
                         name: WithPos::new(func_name, pos),
                         params: params.clone(),
-                        pure: false,
                         result: result.clone(),
                     };
 
@@ -774,18 +589,13 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     if let Some(ref result) = *result {
                         self.get_type(result, AddError)
                     }
-                    else if pure {
-                        Type::Answer
-                    }
                     else {
-                        Type::Unit
+                        Type::Answer
                     };
 
                 {
                     let old_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-                    let old_escaping_vars = mem::take(&mut self.escaping_vars);
-                    let old_in_closure = self.in_closure;
-                    self.in_closure = true;
+                    let old_escaping_vars = mem::take(&mut self.escaping_var_locations);
 
                     // TODO: error when name already exist?
                     let mut param_names = vec![];
@@ -798,37 +608,47 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                             self.duplicate_param(param);
                         }
                     }
-                    param_names.push(self.symbols.symbol(CLOSURE_PARAM));
+                    let closure_param_symbol = self.symbols.symbol(CLOSURE_PARAM);
+                    param_names.push(closure_param_symbol);
                     parameters.push(record_type.clone());
-                    self.env.enter_var(func_name, Entry::Fun {
-                        access_outside_vars: false, // False because the outside variables are in the closure environment.
-                        external: false,
-                        label: Label::with_name(&self.strings.get(func_name).expect("strings get")),
-                        level: func_level.clone(),
-                        parameters: parameters.clone(),
-                        pure: false,
-                        result: result_type.clone(),
-                    });
 
                     self.env.begin_scope();
                     for field in &env_fields {
                         self.env.enter_var(field.ident, Entry::RecordField { record: record_type.clone() });
                     }
+
+                    let closure_type = parameters.last().expect("closure parameter").clone();
+                    let mut function_type = None;
+                    if let Type::Record { ref types, .. } = closure_type {
+                        for &(ident, ref typ) in types {
+                            if ident == name.node {
+                                function_type = Some(typ.clone());
+                            }
+                        }
+                    }
+                    let function_type = function_type.unwrap_or(closure_type);
+                    let access = func_level.formals().last().expect("closure formal").clone();
+                    self.env.enter_var(name.node, Entry::Var { access, typ: function_type });
+
                     for ((param, name), access) in parameters.into_iter().zip(param_names).zip(func_level.formals().into_iter()) {
+                        if type_is_collectable(&param) {
+                            self.temp_map.insert::<F>(&access.1);
+                        }
                         self.env.enter_var(name, Entry::Var { access, typ: param });
                     }
+                    self.env.enter_escape(closure_param_symbol, false);
+
                     // TODO: forbid declaring normal functions in closure (because they could
                     // access variables from outside the closure)?
                     // Or could we just put the variables in the closure?
                     let exp = self.trans_exp(&function.body, &func_level, done_label.clone(), true);
                     self.check_types(&result_type, &exp.ty, function.body.pos);
                     let current_temp_map = mem::replace(&mut self.temp_map, TempMap::new());
-                    let escaping_vars = mem::take(&mut self.escaping_vars);
-                    self.gen.proc_entry_exit(&func_level, exp.exp, current_temp_map, escaping_vars);
+                    let escaping_var_locations = mem::take(&mut self.escaping_var_locations);
+                    self.gen.proc_entry_exit(&func_level, exp.exp, current_temp_map, escaping_var_locations);
                     self.env.end_scope();
 
-                    self.in_closure = old_in_closure;
-                    self.escaping_vars = old_escaping_vars;
+                    self.escaping_var_locations = old_escaping_vars;
                     self.temp_map = old_temp_map;
                 }
 
@@ -837,14 +657,12 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     parameters.push(self.get_type(&param.node.typ, DontAddError));
                 }
 
-                let ty = Type::Function {
+                let ty = Type::Closure {
                     parameters,
                     return_type: Box::new(result_type),
                 };
 
-                self.closure_index += 1;
-
-                let label = self.symbols.symbol(&name);
+                let label = func_name;
                 let mut fields = vec![WithPos::new(RecordField {
                     expr: WithPos::new(Expr::ClosurePointer {
                         label,
@@ -860,9 +678,9 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 }
 
                 let closure = self.trans_exp(&WithPos::new(Expr::Record {
-                    fields,
-                    typ: WithPos::new(closure_symbol, pos),
-                }, pos), level, done_label, true);
+                        fields,
+                        typ: WithPos::new(closure_symbol, pos),
+                    }, pos), level, done_label, true);
                 ExpTy {
                     exp: closure.exp,
                     ty,
@@ -872,35 +690,24 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 let var = self.trans_exp(this, level, done_label, true);
                 if ident.node == self.symbols.symbol(CLOSURE_FIELD) {
                     return ExpTy {
-                        exp: field_access::<F>(var.exp, 0, FieldType::Record), // TODO: do we really want to hard-code this?
+                        exp: field_access::<F>(var.exp, 0), // TODO: do we really want to hard-code this?
                         ty: var.ty.clone(),
                     };
                 }
-                self.add_error(Error::NotARecordOrClass {
+                self.add_error(Error::NotARecord {
                     pos: this.pos,
                     typ: var.ty,
                 });
                 EXP_TYPE_ERROR
             },
             Expr::Field { ref ident, ref this } => {
-                let var = self.trans_exp(this, level, done_label, true);
+                let var = self.trans_exp(this, level, done_label.clone(), true);
                 match var.ty {
-                    Type::Class { name: class_type, ref fields, .. } => {
-                        for (index, class_field) in fields.iter().enumerate() {
-                            if class_field.name == ident.node {
-                                return ExpTy {
-                                    exp: field_access::<F>(var.exp, index, FieldType::Class),
-                                    ty: class_field.typ.clone(),
-                                };
-                            }
-                        }
-                        self.unexpected_field(ident, ident.pos, class_type)
-                    },
                     Type::Record { name: record_type, ref types, .. } => {
                         for (index, &(name, ref typ)) in types.iter().enumerate() {
                             if name == ident.node {
                                 return ExpTy {
-                                    exp: field_access::<F>(var.exp, index, FieldType::Record),
+                                    exp: field_access::<F>(var.exp, index),
                                     ty: typ.clone(),
                                 };
                             }
@@ -909,7 +716,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     },
                     Type::Error => EXP_TYPE_ERROR,
                     typ => {
-                        self.add_error(Error::NotARecordOrClass {
+                        self.add_error(Error::NotARecord {
                             pos: this.pos,
                             typ,
                         });
@@ -923,19 +730,13 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     ty: Type::Int,
                 }
             },
-            Expr::FunctionPointer { ref label } => {
-                ExpTy {
-                    exp: Exp::Name(label.clone()),
-                    ty: Type::Int,
-                }
-            },
             Expr::FunctionPointerCall { ref args, closure_name, ref function } => {
                 let pos = function.pos;
                 let function = self.trans_exp(function, level, done_label.clone(), true);
 
                 let (parameters, result) =
                     match function.ty {
-                        Type::Function { ref parameters, ref return_type, .. } => (parameters, return_type),
+                        Type::Closure { ref parameters, ref return_type } | Type::Function { ref parameters, ref return_type } => (parameters, return_type),
                         Type::Error => return EXP_TYPE_ERROR,
                         _ => return self.not_callable(&function.ty, pos),
                     };
@@ -1006,81 +807,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     ty: result.ty,
                 }
             },
-            Expr::MethodCall { ref args, ref method, ref this } => {
-                let this = self.trans_exp(this, level, done_label.clone(), true);
-                let methods =
-                    match this.ty {
-                        Type::Class { ref methods, .. } => {
-                            methods
-                        },
-                        _ => {
-                            return self.undefined_method(method.node, method.pos)
-                        },
-                    };
-
-                for (index, class_method) in methods.iter().enumerate() {
-                    if method.node == class_method.name.node {
-                        let mut expr_args = vec![this.exp];
-                        let method_type = &class_method.typ;
-                        if method_type.param_types.len() != args.len() {
-                            self.add_error(Error::InvalidNumberOfParams {
-                                actual: args.len(),
-                                expected: method_type.param_types.len(),
-                                pos,
-                            });
-                        }
-                        for (arg, param) in args.iter().zip(method_type.param_types.iter()) {
-                            let exp = self.trans_exp(arg, level, done_label.clone(), true);
-                            self.check_types(param, &exp.ty, arg.pos);
-                            expr_args.push(exp.exp);
-                        }
-                        let result = &method_type.return_type;
-                        let collectable_return_type = type_is_collectable(result);
-                        let current_level = self.methods_level.get(&(class_method.class_name, method.node)).expect("level");
-                        let exp = method_call(index, expr_args, level, current_level, collectable_return_type, self.in_closure);
-                        return ExpTy {
-                            exp,
-                            ty: self.actual_ty(result),
-                        }
-                    }
-                }
-
-                self.undefined_method(method.node, method.pos)
-            },
-            Expr::New { ref class_name } => {
-                // TODO: forbid calling new Object?
-                let class = self.get_type(class_name, AddError);
-                let (data_layout, fields, vtable_name) =
-                    match class {
-                        Type::Class { ref data_layout, ref fields, ref vtable_name, .. } => {
-                            (self.gen.string_literal(data_layout.clone()), fields.clone(), vtable_name.clone())
-                        },
-                        Type::Error => (Exp::Error, vec![], Label::new()),
-                        _ => {
-                            self.add_error(Error::UnexpectedType {
-                                kind: "record".to_string(),
-                                pos: class_name.pos,
-                            });
-                            return EXP_TYPE_ERROR;
-                        },
-                    };
-                // NOTE: we put the class on the stack immediately, because it could contain
-                // heap-allocated values, which could causes the heap to be moved.
-                let access = gen::alloc_local(level, true);
-                self.temp_map.insert::<F>(&access.1);
-                if let Some(stack_var) = access.1.as_stack() {
-                    self.escaping_vars.push(stack_var);
-                }
-                let mut field_exprs = vec![];
-                for field in &fields {
-                    field_exprs.push(self.trans_exp(&field.value, level, done_label.clone(), false).exp);
-                }
-                let exp = class_create::<F>(access, data_layout, field_exprs, vtable_name, self.in_closure);
-                ExpTy {
-                    exp,
-                    ty: class,
-                }
-            },
             Expr::Nil =>
                 ExpTy {
                     exp: num(0),
@@ -1216,73 +942,51 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
             Expr::Variable(ref ident) => {
                 match self.env.look_var(ident.node).cloned() { // TODO: remove this clone.
                     Some(Entry::Var { ref access, ref typ, }) => {
+                        let exp = simple_var(access.clone(), level);
                         ExpTy {
-                            exp: simple_var(access.clone(), level, self.in_closure),
+                            exp,
                             ty: self.actual_ty(typ),
                         }
                     },
-                    Some(Entry::ClassField { class }) => {
-                        let fields =
-                            match class {
-                                Type::Class { ref fields, .. } => fields,
-                                _ => unreachable!(),
-                            };
-                        for (index, class_field) in fields.iter().enumerate() {
-                            if class_field.name == ident.node {
-                                let this = self.trans_exp(&WithPos::dummy(Expr::Variable(WithPos::dummy(self.self_symbol))),
-                                    level, done_label, true);
-                                return ExpTy {
-                                    exp: field_access::<F>(this.exp, index, FieldType::Class),
-                                    ty: class_field.typ.clone(),
-                                };
+                    Some(Entry::Fun { external, ref parameters, ref param_type_symbols, ref result, ref result_symbol, .. }) => {
+                        let closure =
+                            if external {
+                                let mut args = vec![];
+                                let mut params = vec![];
+                                for (index, param) in param_type_symbols.iter().enumerate() {
+                                    let name = self.symbols.symbol(&format!("__arg{}", index));
+                                    args.push(WithPos::new(Expr::Variable(WithPos::new(name, pos)), pos));
+                                    self.env.enter_escape(name, false);
+                                    params.push(WithPos::new(
+                                        Field {
+                                            escape: false,
+                                            name,
+                                            typ: param.clone(),
+                                        },
+                                        pos,
+                                    ));
+                                }
+                                Expr::Closure {
+                                    body: Box::new(WithPos::new(Expr::Call {
+                                        args,
+                                        function: Box::new(WithPos::new(Expr::Variable(ident.clone()), pos)),
+                                    }, pos)),
+                                    name: WithPos::new(self.symbols.symbol(&format!("_closure_{}", self.strings.get(ident.node).expect("get function name"))), pos),
+                                    params,
+                                    result: result_symbol.clone(),
+                                }
                             }
-                        }
-                        unreachable!();
-                    },
-                    Some(Entry::Fun { access_outside_vars, ref label, ref parameters, ref result, .. }) => {
-                        // Create an empty closure for the function.
-                        if access_outside_vars {
-                            self.add_error(Error::CannotAccessOutsideVars {
-                                pos,
-                            });
-                            return EXP_TYPE_ERROR;
-                        }
-
-                        let mut data_layout = String::new();
-                        data_layout.push('n'); // First field is the function pointer, which is not heap-allocated.
-                        let data_layout = self.gen.string_literal(data_layout);
-
-                        let function_pointer_symbol = self.symbols.symbol(CLOSURE_FIELD);
-
-                        let types = vec![(function_pointer_symbol, Type::Int)];
-
-                        let closure_symbol = self.symbols.symbol(&format!("Closure{}", self.closure_index));
-                        let record_type = Type::Record {
-                            data_layout,
-                            name: closure_symbol,
-                            types,
-                            unique: Unique::new(),
-                        };
-                        self.env.enter_type(closure_symbol, record_type.clone());
+                            else {
+                                unreachable!();
+                            };
 
-                        let ty = Type::Function {
+                        let ty = Type::Closure { // TODO: check if it should always be a closure.
                             parameters: parameters.clone(),
                             return_type: Box::new(result.clone()),
                         };
 
-                        self.closure_index += 1;
-
-                        let fields = vec![WithPos::new(RecordField {
-                            expr: WithPos::new(Expr::FunctionPointer {
-                                label: label.clone(),
-                            }, pos),
-                            ident: function_pointer_symbol,
-                        }, pos)];
+                        let closure = self.trans_exp(&WithPos::new(closure, pos), level, done_label, true);
 
-                        let closure = self.trans_exp(&WithPos::new(Expr::Record {
-                            fields,
-                            typ: WithPos::new(closure_symbol, pos),
-                        }, pos), level, done_label, true);
                         ExpTy {
                             exp: closure.exp,
                             ty,
@@ -1300,7 +1004,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                                 let this = self.trans_exp(&WithPos::dummy(Expr::Variable(WithPos::dummy(closure_symbol))),
                                     level, done_label, true);
                                 return ExpTy {
-                                    exp: field_access::<F>(this.exp, index, FieldType::Record),
+                                    exp: field_access::<F>(this.exp, index),
                                     ty: typ.clone(),
                                 };
                             }
@@ -1310,26 +1014,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                     _ => self.undefined_variable(ident.node, ident.pos),
                 }
             },
-            Expr::While { ref body, ref test } => {
-                if self.in_pure_fun {
-                    self.add_error(Error::NoLoopInPureFun {
-                        pos,
-                    });
-                    return EXP_TYPE_ERROR;
-                }
-
-                let test_expr = self.trans_exp(test, level, done_label, true);
-                self.check_int(&test_expr, test.pos);
-                let old_in_loop = self.in_loop;
-                self.in_loop = true;
-                let while_done_label = Label::new();
-                let result = self.trans_exp(body, level, Some(while_done_label.clone()), true);
-                self.in_loop = old_in_loop;
-                ExpTy {
-                    exp: while_loop(&while_done_label, test_expr.exp, result.exp),
-                    ty: result.ty,
-                }
-            },
         }
     }
 
@@ -1343,7 +1027,7 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
                 let parameters = parameters.iter()
                     .map(|param| self.trans_ty(name, param))
                     .collect();
-                Type::Function {
+                Type::Closure {
                     parameters,
                     return_type: Box::new(self.trans_ty(name, return_type)),
                 }
@@ -1388,52 +1072,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         }
     }
 
-    fn method_label(&self, class: Symbol, method: Symbol) -> Label {
-        Label::with_name(&format!("{}_{}",
-            self.strings.get(class).expect("strings get"),
-            self.strings.get(method).expect("strings get"),
-        ))
-    }
-
-    fn parent_members(&mut self, class: &SymbolWithPos) -> (Vec<ClassField>, String, Vec<ClassMethod>) {
-        let mut parent_fields = vec![];
-        let mut parent_data_layout = vec![];
-        let mut parent_methods: Vec<ClassMethod> = vec![];
-        let mut parent = self.get_type(class, DontAddError);
-        while let Type::Class { ref data_layout, ref fields, name, ref methods, ref parent_class, .. } = parent {
-            parent_fields.push(fields.clone());
-            parent_data_layout.push(data_layout.clone());
-
-            for method in methods {
-                if let Some(parent_method) = parent_methods.iter_mut().find(|parent_method| parent_method.name == method.name) {
-                    parent_method.label = method.label.clone();
-                }
-                else {
-                    parent_methods.push(ClassMethod {
-                        class_name: name,
-                        label: method.label.clone(),
-                        name: method.name.clone(),
-                        typ: method.typ.clone(),
-                    });
-                }
-            }
-
-            if let Some(ref parent_class) = *parent_class {
-                parent = self.get_type(parent_class, DontAddError);
-            }
-            else {
-                break;
-            }
-        }
-        let fields = parent_fields.into_iter().rev()
-            .flatten()
-            .collect();
-        let data_layout = parent_data_layout.into_iter().rev()
-            .collect::<Vec<_>>()
-            .join("");
-        (fields, data_layout, parent_methods)
-    }
-
     fn duplicate_param(&mut self, param: &FieldWithPos) {
         let ident = self.env.var_name(param.node.name);
         self.add_error(Error::DuplicateParam {
@@ -1453,20 +1091,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         EXP_TYPE_ERROR
     }
 
-    fn inherit_methods(&mut self, parent_methods: Vec<ClassMethod>, method_labels: &[ClassMethod]) -> Vec<ClassMethod> {
-        let mut labels = parent_methods.clone();
-        for method in method_labels {
-            if let Some(index) = parent_methods.iter().position(|parent_method| parent_method.name == method.name) {
-                self.check_function_types(&parent_methods[index].typ, &method.typ, method.name.pos);
-                labels[index] = method.clone();
-            }
-            else {
-                labels.push(method.clone());
-            }
-        }
-        labels
-    }
-
     fn missing_field(&mut self, field_type: Symbol, typ: &SymbolWithPos) -> ExpTy {
         let ident = self.env.type_name(field_type);
         let struct_name = self.env.type_name(typ.node);
@@ -1496,16 +1120,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
         EXP_TYPE_ERROR
     }
 
-    fn undefined_method(&mut self, ident: Symbol, pos: Pos) -> ExpTy {
-        let ident = self.env.var_name(ident);
-        self.add_error(Error::Undefined {
-            ident,
-            item: "method".to_string(),
-            pos,
-        });
-        EXP_TYPE_ERROR
-    }
-
     fn undefined_type(&mut self, symbol: &SymbolWithPos) -> Type {
         let ident = self.env.type_name(symbol.node);
         self.add_error(Error::Undefined {
@@ -1538,27 +1152,6 @@ impl<'a, F: Clone + Debug + Frame + PartialEq> SemanticAnalyzer<'a, F> {
     }
 }
 
-#[derive(Debug, PartialEq)]
-struct ClosureField {
-    ident: Symbol,
-    typ: Type,
-}
-
-impl Eq for ClosureField {
-}
-
-impl PartialOrd for ClosureField {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for ClosureField {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.ident.cmp(&other.ident)
-    }
-}
-
 struct EnvFinder<'a, F: Frame> {
     closure_level: Level<F>,
     env: &'a Env<F>,
@@ -1577,21 +1170,42 @@ impl<'a, F: Frame> EnvFinder<'a, F> {
 
 #[allow(clippy::needless_lifetimes)]
 impl<'a, F: Frame + PartialEq> Visitor for EnvFinder<'a, F> {
+    fn visit_closure(&mut self, body: &ExprWithPos) {
+        self.visit_exp(body);
+    }
+
     fn visit_var(&mut self, ident: &SymbolWithPos) {
-        // TODO: panic if trying to access a var from static link?
-        // TODO: support class field as well?
-        if let Some(&Entry::Var { ref access, ref typ, }) = self.env.look_var(ident.node) {
-            if self.closure_level.current != access.0.current {
-                self.fields.insert(ClosureField {
-                    ident: ident.node,
-                    typ: typ.clone(),
-                });
-            }
+        match self.env.look_var(ident.node) {
+            Some(&Entry::Var { ref access, ref typ, }) => {
+                if self.closure_level.current != access.0.current {
+                    self.fields.insert(ClosureField {
+                        ident: ident.node,
+                        typ: typ.clone(),
+                    });
+                }
+            },
+            Some(&Entry::RecordField { ref record }) => {
+                match *record {
+                    Type::Record { ref types, .. } => {
+                        for &(name, ref typ) in types {
+                            if name == ident.node {
+                                self.fields.insert(ClosureField {
+                                    ident: ident.node,
+                                    typ: typ.clone(),
+                                });
+                            }
+                        }
+                    },
+                    _ => unreachable!(),
+                }
+            },
+            _ => (),
         }
     }
 }
 
 fn find_closure_environment<F: Frame + PartialEq>(exp: &ExprWithPos, env: &Env<F>, closure_level: Level<F>) -> BTreeSet<ClosureField> {
+    // FIXME: do not fetch the closure itself (in case of recursive closure).
     let mut finder = EnvFinder::new(env, closure_level);
     finder.visit_exp(exp);
     finder.fields
@@ -1599,7 +1213,7 @@ fn find_closure_environment<F: Frame + PartialEq>(exp: &ExprWithPos, env: &Env<F
 
 fn type_is_collectable(typ: &Type) -> bool {
     match *typ {
-        Type::Array { .. } | Type::Class { .. } | Type::Function { .. } | Type::Record { .. } | Type::String => true,
+        Type::Array { .. } | Type::Closure { .. } | Type::Function { .. } | Type::Record { .. } | Type::String => true,
         _ => false,
     }
 }
diff --git a/tiger/src/token.rs b/tiger/src/token.rs
index 60df644..fb6a5ab 100644
--- a/tiger/src/token.rs
+++ b/tiger/src/token.rs
@@ -29,8 +29,6 @@ pub enum Tok {
     Ampersand,
     Array,
     Arrow,
-    Break,
-    Class,
     CloseCurly,
     CloseParen,
     CloseSquare,
@@ -43,8 +41,6 @@ pub enum Tok {
     End,
     EndOfFile,
     Equal,
-    Extends,
-    For,
     Function,
     Greater,
     GreaterOrEqual,
@@ -55,9 +51,7 @@ pub enum Tok {
     Lesser,
     LesserOrEqual,
     Let,
-    Method,
     Minus,
-    New,
     Nil,
     NotEqual,
     Of,
@@ -66,16 +60,13 @@ pub enum Tok {
     OpenSquare,
     Pipe,
     Plus,
-    Pure,
     Semicolon,
     Slash,
     Star,
     Str(String),
     Then,
-    To,
     Type,
     Var,
-    While,
 }
 
 #[derive(Debug)]
@@ -91,8 +82,6 @@ impl Display for Tok {
                 Ampersand => "&",
                 Array => "array",
                 Arrow => "->",
-                Break => "break",
-                Class => "class",
                 CloseCurly => "}",
                 CloseParen => ")",
                 CloseSquare => "]",
@@ -104,9 +93,7 @@ impl Display for Tok {
                 Else => "else",
                 EndOfFile => "<eof>",
                 Equal => "=",
-                Extends => "extends",
                 End => "end",
-                For => "for",
                 Function => "function",
                 Greater => ">",
                 GreaterOrEqual => ">=",
@@ -117,9 +104,7 @@ impl Display for Tok {
                 Lesser => "<",
                 LesserOrEqual => "<=",
                 Let => "let",
-                Method => "method",
                 Minus => "-",
-                New => "new",
                 Nil => "nil",
                 NotEqual => "<>",
                 Of => "of",
@@ -128,16 +113,13 @@ impl Display for Tok {
                 OpenSquare => "[",
                 Pipe => "|",
                 Plus => "+",
-                Pure => "pure",
                 Semicolon => ";",
                 Slash => "/",
                 Star => "*",
                 Str(ref string) => return format!("{:?}", string),
                 Then => "then",
-                To => "to",
                 Type => "type",
                 Var => "var",
-                While => "while",
             };
             string.to_string()
         })();
diff --git a/tiger/src/types.rs b/tiger/src/types.rs
index cb18b50..fb320a0 100644
--- a/tiger/src/types.rs
+++ b/tiger/src/types.rs
@@ -19,55 +19,18 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-use ast::ExprWithPos;
 use ir::Exp;
 use self::Type::*;
 use symbol::{Symbol, Symbols, SymbolWithPos};
-use temp::Label;
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ClassField {
-    pub name: Symbol,
-    pub typ: Type,
-    pub value: ExprWithPos,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct FunctionType {
-    pub param_types: Vec<Type>,
-    pub return_type: Type,
-}
-
-impl FunctionType {
-    pub fn show(&self, symbols: &Symbols<()>) -> std::string::String {
-        let param_types = self.param_types.iter()
-            .map(|typ| typ.show(symbols))
-            .collect::<Vec<_>>()
-            .join(", ");
-        format!("({}) -> {}", param_types, self.return_type.show(symbols))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ClassMethod {
-    pub class_name: Symbol,
-    pub label: Label,
-    pub name: SymbolWithPos,
-    pub typ: FunctionType,
-}
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Type {
     Array(Box<Type>, Unique),
     Answer,
-    Class {
-        data_layout: std::string::String,
-        fields: Vec<ClassField>,
-        methods: Vec<ClassMethod>,
-        name: Symbol,
-        parent_class: Option<SymbolWithPos>,
-        unique: Unique,
-        vtable_name: Label,
+    // TODO: check if this type is still needed to fix the GC issue.
+    Closure {
+        parameters: Vec<Type>,
+        return_type: Box<Type>,
     },
     Function {
         parameters: Vec<Type>,
@@ -90,7 +53,7 @@ pub enum Type {
 impl Type {
     pub fn is_pointer(&self) -> bool {
         match *self {
-            Array { .. } | Class { .. } | Record { .. } | String  => true,
+            Array { .. } | Closure { .. } | Record { .. } | String  => true,
             Name(_, ref typ) => {
                 if let Some(typ) = typ.as_ref() {
                     typ.is_pointer()
@@ -109,8 +72,7 @@ impl Type {
             Array(ref typ, _) => {
                 format!("[{}]", typ.show(symbols))
             },
-            Class { name, .. } => format!("class {}", symbols.name(name)),
-            Function { ref parameters, ref return_type } => {
+            Closure { ref parameters, ref return_type } | Function { ref parameters, ref return_type } => {
                 let show_parens = parameters.len() != 1;
                 let mut string = std::string::String::new();
                 if show_parens {
@@ -137,7 +99,19 @@ impl Type {
                 }
             },
             Nil => "nil".to_string(),
-            Record { name, .. } => format!("struct {}", symbols.name(name)),
+            Record { name, ref types, .. } => {
+                let mut string = format!("struct {} {{", symbols.name(name));
+                for &(ident, ref typ) in types {
+                     let ident = symbols.name(ident);
+                     string.push_str("    ");
+                     string.push_str(&ident);
+                     string.push_str(": ");
+                     string.push_str(&typ.show(symbols));
+                     string.push('\n');
+                }
+                string.push('}');
+                string
+            },
             String => "string".to_string(),
             Unit => "()".to_string(),
             Error => "type error".to_string(),
diff --git a/tiger/src/visitor.rs b/tiger/src/visitor.rs
index 3443338..5634604 100644
--- a/tiger/src/visitor.rs
+++ b/tiger/src/visitor.rs
@@ -28,7 +28,7 @@ use ast::{
     Operator,
 };
 use position::WithPos;
-use symbol::SymbolWithPos;
+use symbol::{Symbol, SymbolWithPos};
 
 pub trait Visitor {
     fn visit_binary_op(&mut self, left: &ExprWithPos, right: &ExprWithPos) {
@@ -38,23 +38,26 @@ pub trait Visitor {
 
     fn visit_dec(&mut self, declaration: &DeclarationWithPos) {
         match declaration.node {
-            Declaration::ClassDeclaration { ref declarations, .. } => {
-                for declaration in declarations {
-                    self.visit_dec(declaration);
-                }
-            },
             Declaration::Function(ref declarations) => {
                 for &WithPos { node: FuncDeclaration { ref body, .. }, .. } in declarations {
-                    self.visit_exp(body);
+                    self.visit_func_dec(body);
                 }
             },
             Declaration::Type(_) => (),
-            Declaration::VariableDeclaration { ref init, .. } => {
-                self.visit_exp(init);
+            Declaration::VariableDeclaration { ref init, name, .. } => {
+                self.visit_var_dec(name, init);
             },
         }
     }
 
+    fn visit_func_dec(&mut self, body: &ExprWithPos) {
+        self.visit_exp(body);
+    }
+
+    fn visit_var_dec(&mut self, _name: Symbol, init: &ExprWithPos) {
+        self.visit_exp(init);
+    }
+
     fn visit_call(&mut self, function: &ExprWithPos, args: &[ExprWithPos]) {
         self.visit_exp(function);
         for arg in args {
@@ -62,29 +65,25 @@ pub trait Visitor {
         }
     }
 
+    fn visit_closure(&mut self, body: &ExprWithPos) {
+        self.visit_exp(body);
+    }
+
     fn visit_exp(&mut self, expr: &ExprWithPos) {
         match expr.node {
             Expr::Array { ref init, ref size, .. } => {
                 self.visit_exp(size);
                 self.visit_exp(init);
             },
-            Expr::Assign { ref expr, ref var } => {
-                self.visit_exp(var);
-                self.visit_exp(expr);
-            },
-            Expr::Break => {
-            },
             Expr::Call { ref args, ref function } => {
                 self.visit_call(function, args);
             },
-            Expr::Closure { ref body, .. } => {
-                self.visit_exp(body);
-            },
+            Expr::Closure { ref body, .. } => self.visit_closure(body),
             Expr::ClosureParamField { ref this, .. } =>
                 self.visit_exp(this),
             Expr::Field { ref this, .. } =>
                 self.visit_exp(this),
-            Expr::ClosurePointer { .. } | Expr::FunctionPointer { .. } => (),
+            Expr::ClosurePointer { .. } => (),
             Expr::FunctionPointerCall { ref args, ref function, .. } => {
                 self.visit_exp(function);
                 for arg in args {
@@ -105,13 +104,6 @@ pub trait Visitor {
                 }
                 self.visit_exp(body);
             },
-            Expr::MethodCall { ref args, ref this, .. } => {
-                self.visit_exp(this);
-                for arg in args {
-                    self.visit_exp(arg);
-                }
-            },
-            Expr::New { .. } => (),
             Expr::Nil => (),
             Expr::Oper { ref left, oper: WithPos { node: Operator::Plus, .. }, ref right }
             | Expr::Oper { ref left, oper: WithPos { node: Operator::Minus, .. }, ref right }
@@ -148,10 +140,6 @@ pub trait Visitor {
                 self.visit_exp(expr);
             },
             Expr::Variable(ref ident) => self.visit_var(ident),
-            Expr::While { ref body, ref test } => {
-                self.visit_exp(test);
-                self.visit_exp(body);
-            },
         }
     }
 
diff --git a/tiger/tests/array.stdout b/tiger/tests/array.stdout
deleted file mode 100644
index 38838fc..0000000
--- a/tiger/tests/array.stdout
+++ /dev/null
@@ -1,14 +0,0 @@
-0
-10
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
diff --git a/tiger/tests/array.tig b/tiger/tests/array.tig
deleted file mode 100644
index 2976c59..0000000
--- a/tiger/tests/array.tig
+++ /dev/null
@@ -1,14 +0,0 @@
-let type intArray = array of int
-    var len := 12
-    var a := intArray[len] of 0
-    var b := intArray[12] of 7
-    var value := a[0]
-in
-    printi(value);
-    a[0] := 10;
-    printi(a[0]);
-    for i := 0 to len - 1 do
-        a[i] := i;
-    for i := 0 to len - 1 do
-        printi(a[i])
-end
diff --git a/tiger/tests/array2d.tig b/tiger/tests/array2d.tig
deleted file mode 100644
index e0d22f1..0000000
--- a/tiger/tests/array2d.tig
+++ /dev/null
@@ -1,12 +0,0 @@
-let type intArray = array of int
-    type arrayOfArray = array of intArray
-    var myArrayOfArray := arrayOfArray [11] of intArray [14] of 43
-    var myNum := 9
-    var indexing := myArrayOfArray[myNum][0]
-
-    /*var myArrayOfArray := intArray [14] of 43
-    var myNum := 9
-    var indexing := myArrayOfArray[myNum]*/
-in
-    printi(indexing)
-end
diff --git a/tiger/tests/array_assignment.stdout b/tiger/tests/array_assignment.stdout
deleted file mode 100644
index 60f5b4b..0000000
--- a/tiger/tests/array_assignment.stdout
+++ /dev/null
@@ -1,2 +0,0 @@
-10
-12
diff --git a/tiger/tests/array_assignment.tig b/tiger/tests/array_assignment.tig
deleted file mode 100644
index 8e5ca3f..0000000
--- a/tiger/tests/array_assignment.tig
+++ /dev/null
@@ -1,11 +0,0 @@
-let type intArray = array of int
-    var a := intArray[12] of 0
-    var b := intArray[12] of 7
-in (
-    a := b;
-    a[0] := 10;
-    printi(b[0]);
-    b[0] := 12;
-    printi(a[0])
-)
-end
diff --git a/tiger/tests/class.stdout b/tiger/tests/class.stdout
deleted file mode 100644
index fadeb49..0000000
--- a/tiger/tests/class.stdout
+++ /dev/null
@@ -1,16 +0,0 @@
-10
-30
-Passengers: 40
-10
-2
-await
-10
-10
-30
-30
-Truck: 30
-290
-290
-30
-30
-85
diff --git a/tiger/tests/class.tig b/tiger/tests/class.tig
deleted file mode 100644
index b982036..0000000
--- a/tiger/tests/class.tig
+++ /dev/null
@@ -1,69 +0,0 @@
-let var start := 10
-
-    class Vehicle extends Object {
-        var position := start
-        method move(x: int) = (
-            self.position := self.position + x;
-            let var position := 100
-            in
-                position := position + 200
-            end;
-            position := position + x
-        )
-    }
-
-    class Car extends Vehicle {
-        var passengers := 40
-
-        method await(v: Vehicle) =
-            if v.position < position then (
-                v.move(position - v.position)
-            )
-            else
-                self.move(10)
-    }
-
-    class Truck extends Vehicle {
-        method move(x: int) =
-            if x <= 55 then
-                position := position + x
-    }
-
-    var t := new Truck
-    var c := new Car
-    var v : Vehicle := c
-    var vehicle := new Vehicle
-    var truck : Vehicle := t
-in
-    printi(vehicle.position);
-    vehicle.move(10);
-    printi(vehicle.position);
-    print("Passengers: ");
-    printi(c.passengers);
-    c.passengers := 2;
-    printi(c.position);
-    printi(c.passengers);
-
-    print("await\n");
-    printi(c.position);
-    printi(t.position);
-
-    c.move(10);
-    c.await(t);
-    printi(c.position);
-    printi(v.position);
-    print("Truck: ");
-    printi(t.position);
-
-    c.move(60);
-    v.move(70);
-    printi(c.position);
-    printi(v.position);
-    printi(t.position);
-
-    truck.move(100);
-    printi(truck.position);
-
-    truck.move(55);
-    printi(truck.position)
-end
diff --git a/tiger/tests/comments.tig b/tiger/tests/comments.tig
index 179f6ee..f222801 100644
--- a/tiger/tests/comments.tig
+++ b/tiger/tests/comments.tig
@@ -5,6 +5,6 @@ let var N := 8
   */
  */
 in
-    print("N\n")
+    print("N\n", tigerExit)
 end
 
diff --git a/tiger/tests/conditions.tig b/tiger/tests/conditions.tig
index 8fc79fe..0237e03 100644
--- a/tiger/tests/conditions.tig
+++ b/tiger/tests/conditions.tig
@@ -9,30 +9,36 @@ let var num := 42
             "true"
         else
             "false"
-in (
-    if num > 40 then
-        print("num > 40\n")
-    else
-        print("num <= 40\n");
 
-    if num < 40 then
-        print("num < 40\n")
-    else
-        print("num >= 40\n");
+    function step5() =
+        print(false, function() =
+            print("\n", function() =
+                print(true, function() =
+                    print("\n", tigerExit)
+                )
+            )
+        )
 
-    if num > 42 then
-        print("num > 42\n")
-    else
-        print("num <= 42\n");
+    function step4() =
+        if num < 42 then
+            print("num < 42\n", step5)
+        else
+            print("num >= 42\n", step5)
 
-    if num < 42 then
-        print("num < 42\n")
-    else
-        print("num >= 42\n");
+    function step3() =
+        if num > 42 then
+            print("num > 42\n", step4)
+        else
+            print("num <= 42\n", step4)
 
-    print(false);
-    print("\n");
-    print(true);
-    print("\n")
-)
+    function step2() =
+        if num < 40 then
+            print("num < 40\n", step3)
+        else
+            print("num >= 40\n", step3)
+in
+    if num > 40 then
+        print("num > 40\n", step2)
+    else
+        print("num <= 40\n", step2)
 end
diff --git a/tiger/tests/error/assign.tig b/tiger/tests/error/assign.tig
deleted file mode 100644
index 5bfd5f3..0000000
--- a/tiger/tests/error/assign.tig
+++ /dev/null
@@ -1,11 +0,0 @@
-let function test(): int = 0
-
-    class Vehicle extends Object {
-        method move(x: int) =
-            print("move")
-    }
-
-    var v := new Vehicle
-in
-    v.move(10) := 10
-end
diff --git a/tiger/tests/error/class.tig b/tiger/tests/error/class.tig
deleted file mode 100644
index 35db1b8..0000000
--- a/tiger/tests/error/class.tig
+++ /dev/null
@@ -1,46 +0,0 @@
-let var start := 10
-
-    class Vehicle extends Object {
-        var position := start
-        method move(x: int) = (
-            print("move\n");
-            self.position := self.position + x;
-            let var position := 100
-            in
-                position := position + 200
-            end;
-            position := position + x
-        )
-    }
-
-    class Car extends Bike {
-        var passengers := 40
-
-        method await(v: Vehicle) =
-            printi(passengers)
-    }
-
-    class Truck extends Vehicle {
-        method value() =
-            12
-
-        var passengers := self.value()
-
-        method move(v: Vehicle) =
-            printi(0)
-    }
-
-    type Array = {
-        field: int
-    }
-
-    class Vec extends Array {
-        method p() =
-            print("p")
-    }
-
-    var b := new Bike
-    var t: Truck := new Vehicle
-in
-    printi(b.position)
-end
diff --git a/tiger/tests/error/pure.tig b/tiger/tests/error/pure.tig
index 508139d..076824e 100644
--- a/tiger/tests/error/pure.tig
+++ b/tiger/tests/error/pure.tig
@@ -1,4 +1,4 @@
-let pure function test() =
+let function test() =
     let var integer := 12
         type Point = {
                 x: int,
diff --git a/tiger/tests/escapes.tig b/tiger/tests/escapes.tig
index c56b622..ed4371f 100644
--- a/tiger/tests/escapes.tig
+++ b/tiger/tests/escapes.tig
@@ -1,6 +1,6 @@
 let var N := 8
 in
     print("\n\t\\\"\065\
-    	\test\n")
+    	\test\n", tigerExit)
 end
 
diff --git a/tiger/tests/functional.tig b/tiger/tests/functional.tig
index 6494226..7ea4cf2 100644
--- a/tiger/tests/functional.tig
+++ b/tiger/tests/functional.tig
@@ -32,12 +32,35 @@ let type intfun = int -> int
 
     var closure := function(m: int) : int =
         m + 1
+
+    function intToString(i: int): string =
+        let function loop(acc: string, i: int): string =
+            if i = 0 then
+                acc
+            else
+                let var rest := i / 10
+                    var dig := i - rest * 10
+                    function doDigit(): string =
+                        concat(chr(dig + ord("0")), acc)
+                in
+                    loop(doDigit(), rest)
+                end
+        in
+            if i = 0 then
+                "0"
+            else if i < 0 then
+                concat("-", loop("", -i))
+            else
+                loop("", i)
+        end
+
+    var n1 := concat(intToString(addFive(10)), "\n")
+    var n2 := concat(concat(n1, intToString(closure(10))), "\n")
+    var n3 := concat(concat(n2, intToString(getClosure()(12))), "\n")
+    var n4 := concat(concat(n3, intToString(twenty)), "\n")
+    var n5 := concat(concat(n4, intToString(twentyTwo)), "\n")
+    var n6 := concat(concat(n5, intToString(addTen(2))), "\n")
+    var n7 := concat(concat(n6, intToString(addTwentyFour(seventeen))), "\n")
 in
-    printi(addFive(10));
-    printi(closure(10));
-    printi(getClosure()(12));
-    printi(twenty);
-    printi(twentyTwo);
-    printi(addTen(2));
-    printi(addTwentyFour(seventeen))
+    print(n7, tigerExit)
 end
diff --git a/tiger/tests/functions.tig b/tiger/tests/functions.tig
index 7d1cbea..3e64d0b 100644
--- a/tiger/tests/functions.tig
+++ b/tiger/tests/functions.tig
@@ -10,11 +10,33 @@ let function maximum(a: int, b: int): int =
             b
     function sum10(a: int, b: int, c: int, d: int, e: int, f: int, g: int, h: int, i: int, j: int): int =
         a + b + c + d + e + f + g + h + i + j
-in (
-    printi(minimum(42, 24));
-    printi(maximum(42, 24));
-    printi(minimum(24, 42));
-    printi(maximum(24, 42));
-    printi(sum10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
-)
+
+    function intToString(i: int): string =
+        let function loop(acc: string, i: int): string =
+            if i = 0 then
+                acc
+            else
+                let var rest := i / 10
+                    var dig := i - rest * 10
+                    function doDigit(): string =
+                        concat(chr(dig + ord("0")), acc)
+                in
+                    loop(doDigit(), rest)
+                end
+        in
+            if i = 0 then
+                "0"
+            else if i < 0 then
+                concat("-", loop("", -i))
+            else
+                loop("", i)
+        end
+
+    var n1 := concat(intToString(minimum(42, 24)), "\n")
+    var n2 := concat(concat(n1, intToString(maximum(42, 24))), "\n")
+    var n3 := concat(concat(n2, intToString(minimum(24, 42))), "\n")
+    var n4 := concat(concat(n3, intToString(maximum(24, 42))), "\n")
+    var n5 := concat(concat(n4, intToString(sum10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))), "\n")
+in
+    print(n5, tigerExit)
 end
diff --git a/tiger/tests/gc.stdout b/tiger/tests/gc.stdout
index 0dd47bf..cc02a63 100644
--- a/tiger/tests/gc.stdout
+++ b/tiger/tests/gc.stdout
@@ -458,465 +458,6 @@ b vecArray
 25
 b vecArray
 0
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-1
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-2
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-3
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-4
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-5
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-6
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-7
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-8
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-9
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-10
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-11
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-12
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-13
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-14
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-15
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-16
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-17
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-18
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-19
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-20
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-21
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-22
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-23
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-24
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-25
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-26
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-27
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-28
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-29
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-30
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-31
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-32
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-33
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-34
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-35
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-36
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-37
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-38
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-39
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-40
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-41
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-42
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-43
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-44
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-45
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-46
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-47
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-48
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-49
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-50
-120
-122
-124
-126
-114
-103
-125
-array_of_vector
-0
 20
 22
 24
@@ -1386,12 +927,3 @@ b vecArray
 2
 Hello, World
 24
-142
-124
-142
-100
-200
-100
-104
-112
-102
diff --git a/tiger/tests/gc.tig b/tiger/tests/gc.tig
index 637b450..e81dbce 100644
--- a/tiger/tests/gc.tig
+++ b/tiger/tests/gc.tig
@@ -4,71 +4,6 @@ let type Point = {
     }
     type strings = array of string
 
-    class Pos extends Object {
-        var x := 0
-        var y := 0
-
-        method set(x: int, y: int) = (
-            self.x := x;
-            self.y := y
-        )
-    }
-
-    class Vector extends Object {
-        var x := 0
-        var y := 0
-        var z := 0
-        var names := strings[42] of "array_of_vector"
-
-        method set(new_x: int, new_y: int, new_z: int) = (
-            self.x := new_x;
-            self.y := new_y;
-            self.z := new_z
-        )
-    }
-
-    var pos := new Pos
-    var set := (
-        pos.x := 142;
-        pos.y := 124
-    )
-    var corigin := new Pos
-
-    function fc() : Pos =
-        let var pos := new Pos
-        in
-            pos.x := 100;
-            pos.y := 102;
-            pos
-        end
-
-    function gc() : Pos =
-        let var p := fc()
-        in
-            p.x := 104;
-            p
-        end
-    function hc() : Pos =
-        let var p := gc()
-        in
-            p.y := 112;
-            p
-        end
-    var pos10 := hc()
-    type vectorArray = array of Vector
-    var vector := new Vector
-    var set := vector.set(101, 102, 103)
-    var array_of_vector := vectorArray[13] of vector
-    class clist extends Object {
-        var first := 0
-        var rest : clist := nil
-
-        method set(value: int) =
-            first := value
-    }
-    var clist := new clist
-    var set := clist.set(42)
-
     type Vec3D = {
         x: int,
         y: int,
@@ -91,14 +26,18 @@ let type Point = {
     function g() : Point =
         let var p := f()
         in
-            p.x := 4;
-            p
+            Point {
+                x = 4,
+                y = p.y
+            }
         end
     function h() : Point =
         let var p := g()
         in
-            p.y := 12;
-            p
+            Point {
+                x = p.x,
+                y = 12
+            }
         end
     var p10 := h()
     type vecArray = array of Vec3D
@@ -111,90 +50,35 @@ let type Point = {
     var string := concat("Hello, ", "World\n")
     type list = {first: int, rest: list}
     var list := list { first = 42, rest = nil }
-in (
-    for i := 0 to 50 do
-        let var origin := Point {
-                x = 20,
-                y = 21
-            }
-            var p2 := Point {
-                x = 22,
-                y = 23
-            }
-            var p3 := Point {
-                x = 24,
-                y = 25
-            }
-            var p4 := Point {
-                x = 26,
-                y = 27
-            }
-            type intArray = array of int
-            var a := intArray[12] of 14
-            var b := vecArray[12] of Vec3D {
-                x = 1,
-                y = 2,
-                z = 3,
-                names = strings[22] of "b vecArray"
-            }
-            var list := list { first = 43, rest = nil }
-        in
-            list := list { first = 25, rest = list };
-            printi(i);
-            printi(origin.x);
-            printi(p2.x);
-            printi(p3.x);
-            printi(p4.x);
-            printi(a[3]);
-            printi(b[3].z);
-            printi(list.first);
-            print(b[11].names[20]);
-            print("\n")
-        end;
 
-    for i := 0 to 50 do
-        let var origin := new Pos
-            var p2 := new Pos
-            var p3 := new Pos
-            var p4 := new Pos
-            type intArray = array of int
-            var a := intArray[12] of 114
-            var vector := new Vector
-            var b := vectorArray[12] of vector
-            var list := new clist
+    type callback = int -> answer
+    type continuation = () -> answer
+    function fifty_times(callback: callback, afterCallback: continuation) =
+        let function loop(counter: int, callback: callback) =
+            if counter >= 0 then (
+                callback(50 - counter);
+                loop(counter - 1, callback)
+            )
+            else (
+                afterCallback()
+            )
         in
-            origin.set(120, 121);
-            p2.set(122, 123);
-            p3.set(124, 125);
-            p4.set(126, 127);
-            vector.set(101, 102, 103);
-            list.first := 43;
-
-            let var new_list := new clist
-            in
-                new_list.first := 125;
-                new_list.rest := list;
-                list := new_list
-            end;
-            printi(i);
-            printi(origin.x);
-            printi(p2.x);
-            printi(p3.x);
-            printi(p4.x);
-            printi(a[3]);
-            printi(b[3].z);
-            printi(list.first);
-            print(b[11].names[20]);
-            print("\n")
-        end;
-
-    for i := 0 to 50 do
+            loop(50, callback)
+        end
+in (
+    /* FIXME: there's a closure in the main function that is deallocated by the GC.
+     * It seems to be the one sent to fifty_times.
+     * FIXME: perhaps the issue is that the collector sees a function pointer instead of the record for a closure?
+     * FIXME: perhaps we don't mark function parameters as collectible?
+     * ==> Marking them doesn't seem to help.
+     * =====> I didn't mark them for closures. Marking them seems to fix the issue!!!
+     * TODO TODO: if I can't find the issue, log allocated and deallocated addresses.
+     * */
+    fifty_times(function(i: int) =
         let var origin := Point {
                 x = 20,
                 y = 21
             }
-            var closure1 := function() =
-                printi(origin.x)
             var p2 := Point {
                 x = 22,
                 y = 23
@@ -203,20 +87,12 @@ in (
                 x = 24,
                 y = 25
             }
-            var closure2 := function() = (
-                printi(p2.x);
-                printi(p3.x)
-            )
             var p4 := Point {
                 x = 26,
                 y = 27
             }
-            var closure3 := function() =
-                printi(p4.x)
             type intArray = array of int
             var a := intArray[12] of 14
-            var closure4 := function(index: int) =
-                printi(a[3])
             var b := vecArray[12] of Vec3D {
                 x = 1,
                 y = 2,
@@ -224,47 +100,123 @@ in (
                 names = strings[22] of "b vecArray"
             }
             var list := list { first = 43, rest = nil }
-            var closure5 := function(index1: int, index2: int) = (
-                printi(b[index1].z);
-                printi(list.first);
-                print(b[index2].names[20])
-            )
+            var list := list { first = 25, rest = list }
         in
-            list := list { first = 25, rest = list };
-            printi(i);
-            closure1();
-            closure2();
-            closure3();
-            closure4(3);
-            closure5(3, 11);
-            print("\n")
-        end;
-
-    list := list { first = 24, rest = list };
-    printi(point.x);
-    printi(point.y);
-    point.y := 100;
-    printi(point.x);
-    printi(point.y);
-    point.x := 200;
-    printi(point.x);
-    printi(point.y);
-    printi(p10.x);
-    printi(p10.y);
-    printi(array_of_vec[10].y);
-    print(string);
-    printi(list.first);
-
-    printi(pos.x);
-    printi(pos.y);
-    pos.y := 100;
-    printi(pos.x);
-    printi(pos.y);
-    pos.x := 200;
-    printi(pos.x);
-    printi(pos.y);
-    printi(pos10.x);
-    printi(pos10.y);
-    printi(array_of_vector[10].y)
+            printi(i, function() =
+                printi(origin.x, function() =
+                    printi(p2.x, function() =
+                        printi(p3.x, function() =
+                            printi(p4.x, function() =
+                                printi(a[3], function() =
+                                    printi(b[3].z, function() =
+                                        printi(list.first, function() =
+                                            print(b[11].names[20], function() =
+                                                debug("") /* FIXME: we should probably call print here, but I'm not sure which continuation to send. */
+                                                /*print("\n", tigerExit) */
+                                            )
+                                        )
+                                    )
+                                )
+                            )
+                        )
+                    )
+                )
+            )
+        end
+    , function() =
+        fifty_times(function(i: int) =
+            let var origin := Point {
+                    x = 20,
+                    y = 21
+                }
+                var closure1 := function(cont: continuation) =
+                    printi(origin.x, cont)
+                var p2 := Point {
+                    x = 22,
+                    y = 23
+                }
+                var p3 := Point {
+                    x = 24,
+                    y = 25
+                }
+                var closure2 := function(cont: continuation) = (
+                    printi(p2.x, function() =
+                        printi(p3.x, cont)
+                    )
+                )
+                var p4 := Point {
+                    x = 26,
+                    y = 27
+                }
+                var closure3 := function(cont: continuation) =
+                    printi(p4.x, cont)
+                type intArray = array of int
+                var a := intArray[12] of 14
+                var closure4 := function(index: int, cont: continuation) =
+                    printi(a[3], cont)
+                var b := vecArray[12] of Vec3D {
+                    x = 1,
+                    y = 2,
+                    z = 3,
+                    names = strings[22] of "b vecArray"
+                }
+                var list := list { first = 43, rest = nil }
+                var closure5 := function(index1: int, index2: int, cont: continuation) = (
+                    printi(b[index1].z, function() =
+                        printi(list.first, function() =
+                            print(b[index2].names[20], cont)
+                        )
+                    )
+                )
+                var list := list { first = 25, rest = list }
+            in
+                printi(i, function() = (
+                    closure1(function() =
+                        closure2(function() =
+                            closure3(function() =
+                                closure4(3, function() =
+                                    closure5(3, 11, function() =
+                                        debug("") /* FIXME: we should probably call print here, but I'm not sure which continuation to send. */
+                                        /*print("\n", tigerExit) */
+                                    )
+                                )
+                            )
+                        )
+                    )
+                ))
+            end
+        , function() =
+            let var list := list { first = 24, rest = list }
+            in
+                printi(point.x, function() =
+                    printi(point.y, function() =
+                        let var point := Point { x = point.x, y = 100 }
+                        in
+                            printi(point.x, function() =
+                                printi(point.y, function() =
+                                    let var point := Point { x = 200, y = point.y }
+                                    in
+                                        printi(point.x, function() =
+                                            printi(point.y, function() =
+                                                printi(p10.x, function() =
+                                                    printi(p10.y, function() =
+                                                        printi(array_of_vec[10].y, function() =
+                                                            print(string, function() =
+                                                                printi(list.first, tigerExit)
+                                                            )
+                                                        )
+                                                    )
+                                                )
+                                            )
+                                        )
+                                    end
+                                )
+                            )
+                        end
+                    )
+                )
+            end
+        )
+    )
 )
 end
diff --git a/tiger/tests/hello.tig b/tiger/tests/hello.tig
index bb94db1..9824d83 100644
--- a/tiger/tests/hello.tig
+++ b/tiger/tests/hello.tig
@@ -1,2 +1,2 @@
 /* Hello-world */
-print("Hello, World!\n")
+print("Hello, World!\n", tigerExit)
diff --git a/tiger/tests/hello1.tig b/tiger/tests/hello1.tig
index 53cd02f..b7c7bbb 100644
--- a/tiger/tests/hello1.tig
+++ b/tiger/tests/hello1.tig
@@ -1,5 +1,5 @@
-(
-    print("Hello, World!\n");
-    print("2\n");
-    printi(42)
+print("Hello, World!\n", function() =
+    print("2\n", function() =
+        printi(42, tigerExit)
+    )
 )
diff --git a/tiger/tests/hello2.tig b/tiger/tests/hello2.tig
index 0f4a8f0..a40e997 100644
--- a/tiger/tests/hello2.tig
+++ b/tiger/tests/hello2.tig
@@ -1,3 +1,3 @@
 /* Hello-world with function */
-let function hello() = print("Hello, World!\n")
+let function hello() = print("Hello, World!\n", tigerExit)
 in hello() end
diff --git a/tiger/tests/hello3.stdout b/tiger/tests/hello3.stdout
index 60aa2c4..5421f5a 100644
--- a/tiger/tests/hello3.stdout
+++ b/tiger/tests/hello3.stdout
@@ -2,9 +2,6 @@ Hello, World!
 Hello 45
 18
 2
-44
-44
-43
 42
 120
 10
diff --git a/tiger/tests/hello3.tig b/tiger/tests/hello3.tig
index 5e2e3bd..03faa86 100644
--- a/tiger/tests/hello3.tig
+++ b/tiger/tests/hello3.tig
@@ -1,4 +1,4 @@
-let function hello() = print("Hello, World!\n")
+let function hello(c: cont) = print("Hello, World!\n", c)
     var num := 42
     var num: int := 42
     type myNum = int
@@ -13,20 +13,14 @@ let function hello() = print("Hello, World!\n")
         myNum2: int,
         myString: myString
     }
-    function myFunc(myParam: int) = (
-        print("Hello ");
-        printi(myParam)
+    function myFunc(myParam: int, c: cont) = (
+        print("Hello ", function() =
+            printi(myParam, c)
+        )
     )
     function id(myParam: int): int = myParam
     function const(param: int, other: int): int = param
     var myNull: myStruct := nil
-    type intArray = array of int
-    type arrayOfArray = array of intArray
-    var myArray := intArray [10] of 44
-    var myArrayOfArray := arrayOfArray [11] of intArray [14] of 43
-    var indexing := myArray[0]
-    var myNum := 9
-    var indexing := myArrayOfArray[myNum][0]
     var myStruct := myStruct { myNum = 42 }
     var fielding := myStruct.myNum
     var myStruct2 := myStruct2 {
@@ -42,16 +36,18 @@ let function hello() = print("Hello, World!\n")
     type arrayOfStruct = array of myType
     var myArrayOfStruct := arrayOfStruct [12] of myType { myString = myArray [13] of 10 }
     var both := myArrayOfStruct[0].myString[1]
-in (
-    hello();
-    myFunc(45);
-    printi(id(18));
-    printi(const(2, 4));
-    printi(myArray[4]);
-    printi(myArray[0]);
-    printi(indexing);
-    printi(myStruct.myNum);
-    printi(fielding);
-    printi(both)
-)
+in
+    hello(function() =
+        myFunc(45, function() =
+            printi(id(18), function() =
+                printi(const(2, 4), function() =
+                    printi(myStruct.myNum, function() =
+                        printi(fielding, function() =
+                            printi(both, tigerExit)
+                        )
+                    )
+                )
+            )
+        )
+    )
 end
diff --git a/tiger/tests/hello5.tig b/tiger/tests/hello5.tig
index 3376f66..8a10874 100644
--- a/tiger/tests/hello5.tig
+++ b/tiger/tests/hello5.tig
@@ -1,13 +1,7 @@
-let function hello() = print("Hello, World!\n")
+let function hello(c: cont) = print("Hello, World!\n", c)
     type intArray = array of int
 in
-hello();
-print("Test\n");
-5 + 2;
-10 * 11 + 2 / 1 * -42;
-10 * (11 + 2) / 1 * -42;
-intArray [10] of 42
-/*; intArray.field[10] of 32*/
-/*; intArray[10].field of 32*/
-/* ; intArray [10][42] of 42 */
+    hello(function() =
+        print("Test\n", tigerExit)
+    )
 end
diff --git a/tiger/tests/helloPure.tig b/tiger/tests/helloPure.tig
index 2247290..f2fd84a 100644
--- a/tiger/tests/helloPure.tig
+++ b/tiger/tests/helloPure.tig
@@ -1,11 +1,11 @@
-let pure function cont() =
-    getcharP(pure function(char: string) =
-        let pure function next() =
-            printP("\n", exit)
+let function cont() =
+    getchar(function(char: string) =
+        let function next() =
+            print("\n", tigerExit)
         in
-            printP(char, next)
+            print(char, next)
         end
     )
 in
-    printP("Hello, World!\n", cont)
+    print("Hello, World!\n", cont)
 end
diff --git a/tiger/tests/inlining.tig b/tiger/tests/inlining.tig
new file mode 100644
index 0000000..868e28d
--- /dev/null
+++ b/tiger/tests/inlining.tig
@@ -0,0 +1,5 @@
+let function inc(x: int) : int =
+        x + 1
+in
+    printi(inc(10))
+end
diff --git a/tiger/tests/integers.tig b/tiger/tests/integers.tig
index 574cec1..4cddcd8 100644
--- a/tiger/tests/integers.tig
+++ b/tiger/tests/integers.tig
@@ -2,11 +2,33 @@ let var n := 10
     var minus_n := -n
     var addition := n + 2 + minus_n
     var result := minus_n / addition
-in (
-    printi(10 / 2);
-    printi(minus_n);
-    printi(addition);
-    printi(result);
-    printi(200 - n * minus_n)
-)
+
+    function intToString(i: int): string =
+        let function loop(acc: string, i: int): string =
+            if i = 0 then
+                acc
+            else
+                let var rest := i / 10
+                    var dig := i - rest * 10
+                    function doDigit(): string =
+                        concat(chr(dig + ord("0")), acc)
+                in
+                    loop(doDigit(), rest)
+                end
+        in
+            if i = 0 then
+                "0"
+            else if i < 0 then
+                concat("-", loop("", -i))
+            else
+                loop("", i)
+        end
+
+    var n1 := concat(intToString(10 / 2), "\n")
+    var n2 := concat(concat(n1, intToString(minus_n)), "\n")
+    var n3 := concat(concat(n2, intToString(addition)), "\n")
+    var n4 := concat(concat(n3, intToString(result)), "\n")
+    var n5 := concat(concat(n4, intToString(200 - n * minus_n)), "\n")
+in
+    print(n5, tigerExit)
 end
diff --git a/tiger/tests/lib.tig b/tiger/tests/lib.tig
index 5089036..6d7df9d 100644
--- a/tiger/tests/lib.tig
+++ b/tiger/tests/lib.tig
@@ -1 +1 @@
-print(concat("Hello, ", "World!\n"))
+print(concat("Hello, ", "World!\n"), tigerExit)
diff --git a/tiger/tests/loops.stdout b/tiger/tests/loops.stdout
deleted file mode 100644
index 3a77a46..0000000
--- a/tiger/tests/loops.stdout
+++ /dev/null
@@ -1,29 +0,0 @@
-0
-0
-1
-2
-3
-4
-5
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
diff --git a/tiger/tests/loops.tig b/tiger/tests/loops.tig
deleted file mode 100644
index 15fb5d4..0000000
--- a/tiger/tests/loops.tig
+++ /dev/null
@@ -1,36 +0,0 @@
-(
-    let var i := 0
-    in
-        while i < 10 do (
-            printi(i);
-            break;
-            i := i + 1
-        )
-    end;
-
-    let var i := 0
-    in
-        while i < 10 do (
-            printi(i);
-            if i = 5 then
-                break;
-            i := i + 1
-        )
-    end;
-
-    let var i := 0
-        var iter_end := 10
-    in
-        if i < iter_end then
-            while 1 do (
-                printi(i);
-                if i < iter_end then
-                    i := i + 1
-                else
-                    break
-            )
-    end;
-
-    for i := 0 to 10 do
-        printi(i)
-)
diff --git a/tiger/tests/merge.tig b/tiger/tests/merge.tig
index da1abc0..4de492b 100644
--- a/tiger/tests/merge.tig
+++ b/tiger/tests/merge.tig
@@ -1,33 +1,63 @@
-let type any = {any: int}
-    var buffer := getchar()
+let type maybeInt = {isInt: int, num: int}
+    type list = {first: int, rest: list}
+    type intConsumer = maybeInt -> answer
+    type listConsumer = list -> answer
 
-    function readint(any: any) : int =
-        let var i := 0
-            function isdigit(s : string) : int =
-                ord(buffer) >= ord("0") & ord(buffer) <= ord("9")
+    function readint(done: intConsumer) =
+        let function isdigit(s : string) : int =
+                ord(s) >= ord("0") & ord(s) <= ord("9")
+            function nextDigit(accum: int, isInt: int) =
+                let function eatChar(dig: string) =
+                    if isdigit(dig) then
+                        nextDigit(accum * 10 + ord(dig) - ord("0"), 1)
+                    else
+                        done(maybeInt { isInt = isInt, num = accum })
+                in
+                    getchar(eatChar)
+                end
         in
-            while buffer = " " | buffer = "\n" do
-                buffer := getchar();
-            any.any := isdigit(buffer);
-            while isdigit(buffer) do (
-                i := i * 10 + ord(buffer) - ord("0");
-                buffer := getchar()
-            );
-            i
+            nextDigit(0, 0)
         end
 
-    type list = {first: int, rest: list}
+    function reverse(xs: list): list =
+        let function inner(xs: list, acc: list): list =
+            if xs <> nil then (
+                inner(xs.rest, list {
+                    first = xs.first,
+                    rest = acc
+                })
+            )
+            else
+                acc
+        in
+            if xs <> nil then
+                inner(xs.rest, list {
+                    first = xs.first,
+                    rest = nil
+                })
+            else
+                xs
+        end
 
-    function readlist() : list =
-        let var any := any { any = 0 }
-            var i := readint(any)
+    function readlist(done: listConsumer) =
+        let function next(acc: list) = (
+            readint(function(maybeInt: maybeInt) = (
+                if maybeInt.isInt then (
+                    let var first := maybeInt.num
+                    in
+                        next(list { first = first, rest = acc })
+                    end
+                )
+                else (
+                    let var rev := reverse(acc)
+                    in
+                        done(rev)
+                    end
+                )
+            ))
+        )
         in
-            if any.any then
-                list { first = i, rest = readlist() }
-            else (
-                buffer := getchar();
-                nil
-            )
+            next(nil)
         end
 
     function merge(a: list, b: list) : list =
@@ -40,31 +70,35 @@ let type any = {any: int}
         else
             list { first = b.first, rest = merge(a, b.rest) }
 
-    function printint(i: int) =
-        let function f(i: int) =
-            if i > 0 then (
-                f(i / 10);
-                print(chr(i - i / 10 * 10 + ord("0")))
-            )
-        in
-            if i < 0 then (
-                print("-");
-                f(-i)
-            )
-            else if i > 0 then
-                f(i)
-            else
-                print("0")
-        end
+    function printint(i: int, c: cont) =
+        if i = 0 then
+            c()
+        else
+            let var rest := i / 10
+                var dig := i - rest * 10
+                function doDigit() =
+                    print(chr(dig + ord("0")), c)
+            in
+                printint(rest, doDigit)
+            end
 
-    function printlist(l: list) =
+    function printlist(l: list, c: cont) =
         if l = nil then
-            print("\n")
+            print("\n", c)
         else (
-            printint(l.first);
-            print(" ");
-            printlist(l.rest)
+            printint(l.first, function() =
+                print(" ", function() =
+                    printlist(l.rest, tigerExit)
+                )
+            )
         )
 in
-    printlist(merge(readlist(), readlist()))
+    readlist(function(list1: list) = (
+        getchar(function(char: string) = (
+            /* Ignore the character between the lists. */
+            readlist(function(list2: list) =
+                printlist(merge(list1, list2), tigerExit)
+            )
+        ))
+    ))
 end
diff --git a/tiger/tests/nested.tig b/tiger/tests/nested.tig
index 68a658e..8759c45 100644
--- a/tiger/tests/nested.tig
+++ b/tiger/tests/nested.tig
@@ -1,18 +1,42 @@
-let function f() =
+let function intToString(i: int): string =
+        let function loop(acc: string, i: int): string =
+            if i = 0 then
+                acc
+            else
+                let var rest := i / 10
+                    var dig := i - rest * 10
+                    function doDigit(): string =
+                        concat(chr(dig + ord("0")), acc)
+                in
+                    loop(doDigit(), rest)
+                end
+        in
+            if i = 0 then
+                "0"
+            else if i < 0 then
+                concat("-", loop("", -i))
+            else
+                loop("", i)
+        end
+
+    function f(): string =
         let var v := 6
+            var n1 := concat(intToString(v), "\n")
+            var n2 :=
+                let var v := 7
+                in
+                    concat(concat(n1, intToString(v)), "\n")
+                end
+            var n3 := concat(concat(n2, intToString(v)), "\n")
+            var n4 :=
+                let var v := 8
+                in
+                    concat(concat(n3, intToString(v)), "\n")
+                end
+            var n5 := concat(concat(n4, intToString(v)), "\n")
         in
-            printi(v);
-            let var v := 7
-            in
-                printi(v)
-            end;
-            printi(v);
-            let var v := 8
-            in
-                printi(v)
-            end;
-            printi(v)
+            n5
         end
 in
-    f()
+    print(f(), tigerExit)
 end
diff --git a/tiger/tests/pure.stdin b/tiger/tests/pure.stdin
new file mode 100644
index 0000000..df8a08a
--- /dev/null
+++ b/tiger/tests/pure.stdin
@@ -0,0 +1,4 @@
+5
+6
+7
+13
diff --git a/tiger/tests/pure.stdout b/tiger/tests/pure.stdout
new file mode 100644
index 0000000..b9d9d95
--- /dev/null
+++ b/tiger/tests/pure.stdout
@@ -0,0 +1,3 @@
+120
+720
+5040
diff --git a/tiger/tests/pure.tig b/tiger/tests/pure.tig
index 8c8bda4..b6c3a6b 100644
--- a/tiger/tests/pure.tig
+++ b/tiger/tests/pure.tig
@@ -1,47 +1,48 @@
-/* FIXME: this does not work because closures were implemented without static links. */
 let type intConsumer = int -> answer
 
-    pure function isDigit(s: string) : int =
+    function isDigit(s: string) : int =
         ord(s) >= ord("0") & ord(s) <= ord("9")
 
-    pure function getInt(done: intConsumer) =
-        let var nextDigit := pure function(accum: int) =
-            let var eatChar := pure function(dig: string) =
+    function getInt(done: intConsumer) =
+        let function nextDigit(accum: int) =
+            let function eatChar(dig: string) =
                 if isDigit(dig) then
-                    nextDigit(accum * 10 + ord(dig))
+                    nextDigit(accum * 10 + ord(dig) - ord("0"))
                 else
                     done(accum)
             in
-                getcharP(eatChar)
+                getchar(eatChar)
             end
         in
             nextDigit(0)
         end
 
-    pure function putInt(i: int, c: cont) =
+    function putInt(i: int, c: cont) =
         if i = 0 then
             c()
         else
             let var rest := i / 10
                 var dig := i - rest * 10
-                var doDigit := pure function() =
-                    printP(chr(dig), c)
+                function doDigit() =
+                    print(chr(dig + ord("0")), c)
             in
                 putInt(rest, doDigit)
             end
 
-    pure function factorial(i: int) : int =
+    function factorial(i: int) : int =
         if i = 0 then
             1
         else
             i * factorial(i - 1)
 
-    pure function loop(i: int) =
+    function loop(i: int) =
         if i > 12 then
-            exit()
+            tigerExit()
         else
-            let pure function next() =
-                getInt(loop)
+            let function ask() =
+                    getInt(loop)
+                function next() =
+                    print("\n", ask)
             in
                 putInt(factorial(i), next)
             end
diff --git a/tiger/tests/pureClosure.stdin b/tiger/tests/pureClosure.stdin
new file mode 100644
index 0000000..df8a08a
--- /dev/null
+++ b/tiger/tests/pureClosure.stdin
@@ -0,0 +1,4 @@
+5
+6
+7
+13
diff --git a/tiger/tests/pureClosure.stdout b/tiger/tests/pureClosure.stdout
new file mode 100644
index 0000000..b9d9d95
--- /dev/null
+++ b/tiger/tests/pureClosure.stdout
@@ -0,0 +1,3 @@
+120
+720
+5040
diff --git a/tiger/tests/pureClosure.tig b/tiger/tests/pureClosure.tig
new file mode 100644
index 0000000..9a3a5f6
--- /dev/null
+++ b/tiger/tests/pureClosure.tig
@@ -0,0 +1,51 @@
+let type intConsumer = int -> answer
+
+    function isDigit(s: string) : int =
+        ord(s) >= ord("0") & ord(s) <= ord("9")
+
+    function getInt(done: intConsumer) =
+        let function nextDigit(accum: int) =
+            let function eatChar(dig: string) =
+                if isDigit(dig) then
+                    nextDigit(accum * 10 + ord(dig) - ord("0"))
+                else
+                    done(accum)
+            in
+                getchar(function(char: string) = eatChar(char))
+            end
+        in
+            nextDigit(0)
+        end
+
+    function putInt(i: int, c: cont) =
+        if i = 0 then
+            c()
+        else
+            let var rest := i / 10
+                var dig := i - rest * 10
+                function doDigit() =
+                    print(chr(dig + ord("0")), c)
+            in
+                putInt(rest, function() = doDigit())
+            end
+
+    function factorial(i: int) : int =
+        if i = 0 then
+            1
+        else
+            i * factorial(i - 1)
+
+    function loop(i: int) =
+        if i > 12 then
+            tigerExit()
+        else
+            let function ask() =
+                    getInt(loop)
+                function next() =
+                    print("\n", ask)
+            in
+                putInt(factorial(i), next)
+            end
+in
+    getInt(loop)
+end
diff --git a/tiger/tests/pureTree.tig b/tiger/tests/pureTree.tig
index 15b02b6..8d818e6 100644
--- a/tiger/tests/pureTree.tig
+++ b/tiger/tests/pureTree.tig
@@ -7,7 +7,7 @@ let type key = int
         right: tree
     }
 
-    pure function look(t: tree, k: key): binding =
+    function look(t: tree, k: key): binding =
         if t = nil then
             "<not-found>"
         else if k < t.key then
@@ -17,7 +17,7 @@ let type key = int
         else
             t.binding
 
-    pure function enter(t: tree, k: key, b: binding): tree =
+    function enter(t: tree, k: key, b: binding): tree =
         if t = nil then
             tree {
                 key = k,
@@ -64,13 +64,18 @@ let type key = int
         }
     }
 in
-    print(look(tree, 15));
-    print("\n");
-    let var newTree := enter(tree, 20, "20")
-    in
-        print(look(tree, 20));
-        print("\n");
-        print(look(newTree, 20));
-        print("\n")
-    end
+    print(look(tree, 15), function() =
+        print("\n", function() =
+            let var newTree := enter(tree, 20, "20")
+            in
+                print(look(tree, 20), function() =
+                    print("\n", function() =
+                        print(look(newTree, 20), function() =
+                            print("\n", tigerExit)
+                        )
+                    )
+                )
+            end
+        )
+    )
 end
diff --git a/tiger/tests/record.stdout b/tiger/tests/record.stdout
index 7755c5a..be6d407 100644
--- a/tiger/tests/record.stdout
+++ b/tiger/tests/record.stdout
@@ -1,6 +1,2 @@
 42
 24
-42
-100
-200
-100
diff --git a/tiger/tests/record.tig b/tiger/tests/record.tig
index 28a1018..6560dd3 100644
--- a/tiger/tests/record.tig
+++ b/tiger/tests/record.tig
@@ -11,13 +11,8 @@ let type Point = {
         y = 0
     }
 in (
-    printi(point.x);
-    printi(point.y);
-    point.y := 100;
-    printi(point.x);
-    printi(point.y);
-    point.x := 200;
-    printi(point.x);
-    printi(point.y)
+    printi(point.x, function() =
+        printi(point.y, tigerExit)
+    )
 )
 end
diff --git a/tiger/tests/spill.tig b/tiger/tests/spill.tig
index 3b4470a..0c82410 100644
--- a/tiger/tests/spill.tig
+++ b/tiger/tests/spill.tig
@@ -9,15 +9,24 @@ let var a := 1
     var i := 9
     var j := 10
 in (
-    printi(a);
-    printi(b);
-    printi(c);
-    printi(d);
-    printi(e);
-    printi(f);
-    printi(g);
-    printi(h);
-    printi(i);
-    printi(j)
+    printi(a, function() =
+        printi(b, function() =
+            printi(c, function() =
+                printi(d, function() =
+                    printi(e, function() =
+                        printi(f, function() =
+                            printi(g, function() =
+                                printi(h, function() =
+                                    printi(i, function() =
+                                        printi(j, tigerExit)
+                                    )
+                                )
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    )
 )
 end
diff --git a/tiger/tests/staticLink.tig b/tiger/tests/staticLink.tig
new file mode 100644
index 0000000..7f532fa
--- /dev/null
+++ b/tiger/tests/staticLink.tig
@@ -0,0 +1,21 @@
+let var n := 10
+    var output := concat("Hello, ", "world\n")
+    function test3() = (
+        print(output);
+        printi(n)
+    )
+    function test() =
+        let var s := 12
+            function test2() = (
+                print(output);
+                test3();
+                printi(n);
+                printi(s)
+            )
+        in
+            printi(n);
+            test2()
+        end
+in
+    test()
+end
diff --git a/tiger/tests/strings.tig b/tiger/tests/strings.tig
index 3ded484..e6bac39 100644
--- a/tiger/tests/strings.tig
+++ b/tiger/tests/strings.tig
@@ -1,15 +1,22 @@
 (
-    printi(ord("a"));
-    print(chr(97));
-    print("\n");
-    print(chr(ord("a")));
-    print("\n");
-    if "a" = "a" then
-        print("true\n");
-    let var char := getchar()
-    in (
-        print(char);
-        print("\n")
+    printi(ord("a"), function() =
+        print(chr(97), function() =
+            print("\n", function() =
+                print(chr(ord("a")), function() =
+                    print("\n", function() =
+                        if "a" = "a" then
+                            print("true\n", function() =
+                                getchar(function(char: string) =
+                                    print(char, function() =
+                                        print("\n", tigerExit)
+                                    )
+                                )
+                            )
+                        else
+                            tigerExit()
+                    )
+                )
+            )
+        )
     )
-    end
 )
diff --git a/tiger/tests/test.rs b/tiger/tests/test.rs
index 82f363c..9774f4d 100644
--- a/tiger/tests/test.rs
+++ b/tiger/tests/test.rs
@@ -19,6 +19,8 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+// TODO: run the error tests.
+
 use std::fs::{self, remove_file};
 use std::io::{Read, Write};
 use std::path::Path;
@@ -27,12 +29,9 @@ use std::process::{Command, Stdio};
 #[test]
 fn test_execution() {
     let files = [
-        "array",
-        "array_assignment",
-        "class",
+        // TODO: remove the test files that are not needed anymore (array, …).
         "comments",
         "conditions",
-        "cycle",
         "escapes",
         "functional",
         "functions",
@@ -45,12 +44,13 @@ fn test_execution() {
         "helloPure",
         "integers",
         "lib",
-        "loops",
         "merge",
         "nested",
-        "prettyprint",
+        //"prettyprint",
+        "pure",
+        "pureClosure",
         "pureTree",
-        "queens",
+        //"queens",
         "record",
         "spill",
         "strings",
diff --git a/tiger/tests/vars.tig b/tiger/tests/vars.tig
index a779a28..ae08c4e 100644
--- a/tiger/tests/vars.tig
+++ b/tiger/tests/vars.tig
@@ -2,8 +2,10 @@ let var i := 0
     var j := 1
     var k := 2
 in (
-    printi(i);
-    printi(j);
-    printi(k)
+    printi(i, function() =
+        printi(j, function() =
+            printi(k, tigerExit)
+        )
+    )
 )
 end