diff --git a/examples/test.lua b/examples/test.lua
index 4556aa4..3bf9b1e 100644
--- a/examples/test.lua
+++ b/examples/test.lua
@@ -1,5 +1,6 @@
-function test()
-    return 5
+function add(x)
+    return x
 end
 
-global c = print(test())
\ No newline at end of file
+global d = add(5)
+global c = print(d)
\ No newline at end of file
diff --git a/src/main.rs b/src/main.rs
index 7eb499d..e52b828 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -87,9 +87,9 @@ fn main() {
 
     let closure = vm.create_closure(0);
 
-    let mut run = closure.run();
+    let mut run = closure.run(Vec::new());
 
     while run.next().is_none() {}
 
-    // dbg!(&vm.environment.borrow().globals);
+    dbg!(&vm.environment.borrow().globals);
 }
diff --git a/src/vm.rs b/src/vm.rs
index f311ef4..c43f488 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -98,7 +98,7 @@ impl Debug for Value {
                 .field(&LuaNumber::from_bits(*arg0))
                 .finish(),
             Self::RustFunction(arg0) => f.debug_tuple("RustFunction").field(arg0).finish(),
-            Self::Function(arg0) => f.debug_tuple("Function").field(arg0).finish(),
+            Self::Function(_) => f.debug_tuple("Function").finish(),
             Self::Nil => write!(f, "Nil"),
         }
     }
@@ -135,11 +135,15 @@ pub struct Closure {
 }
 
 impl Closure {
-    pub fn run(&self) -> ClosureRunner {
+    pub fn run(&self, params: Vec<Value>) -> ClosureRunner {
+        let mut stack = HashMap::new();
+        for (i, param) in params.iter().enumerate() {
+            stack.insert(i as u16, param.clone());
+        }
         ClosureRunner {
             closure: self.clone(),
             program_counter: 0,
-            stack: HashMap::new(),
+            stack,
             inner: None,
             return_registers: Vec::new(),
         }
@@ -159,8 +163,9 @@ impl ClosureRunner {
         if let Some(inner) = &mut self.inner {
             if let Some(ret_values) = inner.next() {
                 self.inner = None;
-                for (value, reg) in ret_values.iter().zip(&self.return_registers) {
-                    self.stack.insert(*reg, value.clone());
+                for (i, reg) in self.return_registers.iter().enumerate() {
+                    self.stack
+                        .insert(*reg, ret_values.get(i).cloned().unwrap_or(Value::Nil));
                 }
             } else {
                 return None;
@@ -209,12 +214,12 @@ impl ClosureRunner {
                     }
                 }
                 Instruction::Call(func_reg, param_len, ret_len) => {
+                    let mut params = Vec::new();
+                    for i in 0..*param_len {
+                        params.push(self.stack.get(&(func_reg + i + 1)).unwrap().clone());
+                    }
                     match self.stack.get(func_reg).unwrap_or(&Value::Nil) {
                         Value::RustFunction(func) => {
-                            let mut params = Vec::new();
-                            for i in 0..*param_len {
-                                params.push(self.stack.get(&(func_reg + i + 1)).unwrap().clone());
-                            }
                             let ret_values = func.borrow_mut().execute(params);
                             for i in 0..=(*ret_len - 2) {
                                 self.stack.insert(
@@ -228,7 +233,7 @@ impl ClosureRunner {
                             for i in 0..=(*ret_len - 2) {
                                 self.return_registers.push(*func_reg + i);
                             }
-                            self.inner = Some(Box::new(closure.run()));
+                            self.inner = Some(Box::new(closure.run(params)));
                         }
                         _ => panic!(),
                     }