diff --git a/kraken.krak b/kraken.krak
index 0173033..82c323d 100644
--- a/kraken.krak
+++ b/kraken.krak
@@ -35,13 +35,12 @@ fun main(argc: int, argv: **char):int {
         file_contents = string("RealGoal = boolean_expression ;\n") + file_contents
         doing_repl = true
     } else if (string(argv[1]) == "-v" || string(argv[1]) == "--version") {
-        var version_c_string = "fail"
-        /*var version_c_string = #ctce(fun(): *char {*/
-            /*var version_string = string("Self-hosted Kraken compiler \"Kalypso\" - revision ") + from_system_command(string("git rev-list HEAD | wc -l"), 100) +*/
-                /*", commit: " + from_system_command(string("git rev-parse HEAD"), 100) +*/
-                /*", compile date: " + from_system_command(string("date"), 100) */
-            /*return version_string.toCharArray()*/
-        /*}())*/
+        var version_c_string = #ctce(fun(): *char {
+            var version_string = string("Self-hosted Kraken compiler \"Kalypso\" - revision ") + from_system_command(string("git rev-list HEAD | wc -l"), 100) +
+                ", commit: " + from_system_command(string("git rev-parse HEAD"), 100) +
+                ", compile date: " + from_system_command(string("date"), 100) 
+            return version_string.toCharArray()
+        }())
         println(version_c_string)
         exit(0)
     }
diff --git a/stdlib/defer_lower.krak b/stdlib/defer_lower.krak
index e80e44a..be011a9 100644
--- a/stdlib/defer_lower.krak
+++ b/stdlib/defer_lower.krak
@@ -12,32 +12,33 @@ import ast_transformation:*
 import pass_common:*
 
 fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_syntax: *map<*ast_node, *tree<symbol>>) {
-    var enclosing_function = null<ast_node>()
+    var enclosing_function_stack = stack<*ast_node>()
     var visited = set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
-        var defer_double_stack = stack<stack<*ast_node>>()
+        var defer_triple_stack = stack<stack<stack<*ast_node>>>()
         var loop_stack = stack(-1)
         var helper_before = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
             match(*node) {
                 ast_node::defer_statement(backing) {
                     if (is_code_block(parent_chain->top())) {
                         remove(node, parent_chain)
-                        defer_double_stack.top().push(backing.statement)
+                        defer_triple_stack.top().top().push(backing.statement)
                     } else {
                         replace_with_in(node, backing.statement, parent_chain)
                     }
                 }
                 ast_node::code_block(backing) {
-                    defer_double_stack.push(stack<*ast_node>())
+                    defer_triple_stack.top().push(stack<*ast_node>())
                 }
                 ast_node::for_loop(backing) {
-                    loop_stack.push(defer_double_stack.size())
+                    loop_stack.push(defer_triple_stack.top().size())
                 }
                 ast_node::while_loop(backing) {
-                    loop_stack.push(defer_double_stack.size())
+                    loop_stack.push(defer_triple_stack.top().size())
                 }
                 ast_node::function(backing) {
-                    enclosing_function = node
+                    enclosing_function_stack.push(node)
+                    defer_triple_stack.push(stack<stack<*ast_node>>())
                 }
             }
         }
@@ -46,8 +47,8 @@ fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_t
                 ast_node::branching_statement(backing) {
                     var block = ast_code_block_ptr()
                     replace_with_in(node, block, parent_chain)
-                    for (var i = 0; i < defer_double_stack.size() - loop_stack.top(); i++;)
-                        block->code_block.children.add_all(defer_double_stack.from_top(i).reverse_vector())
+                    for (var i = 0; i < defer_triple_stack.top().size() - loop_stack.top(); i++;)
+                        block->code_block.children.add_all(defer_triple_stack.top().from_top(i).reverse_vector())
                     block->code_block.children.add(node)
                 }
                 ast_node::return_statement(backing) {
@@ -55,22 +56,22 @@ fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_t
                     replace_with_in(node, block, parent_chain)
                     var return_value = node->return_statement.return_value
                     if (return_value) {
-                        if (get_ast_type(enclosing_function)->return_type->is_ref)
+                        if (get_ast_type(enclosing_function_stack.top())->return_type->is_ref)
                             return_value = make_operator_call("&", vector(return_value))
                         var temp_return = ast_identifier_ptr("temp_boom_return", get_ast_type(return_value)->clone_without_ref(), block)
                         block->code_block.children.add(ast_declaration_statement_ptr(temp_return, null<ast_node>(), false))
                         block->code_block.children.add(assign_or_copy_construct_statement(temp_return, return_value))
                         // dereference so that the real ref can take it back
-                        if (get_ast_type(enclosing_function)->return_type->is_ref)
+                        if (get_ast_type(enclosing_function_stack.top())->return_type->is_ref)
                             temp_return = make_operator_call("*", vector(temp_return))
                         node->return_statement.return_value = temp_return
                     }
-                    for (var i = 0; i < defer_double_stack.size(); i++;)
-                        block->code_block.children.add_all(defer_double_stack.from_top(i).reverse_vector())
+                    for (var i = 0; i < defer_triple_stack.top().size(); i++;)
+                        block->code_block.children.add_all(defer_triple_stack.top().from_top(i).reverse_vector())
                     block->code_block.children.add(node)
                 }
                 ast_node::code_block(backing) {
-                    node->code_block.children.add_all(defer_double_stack.pop().reverse_vector())
+                    node->code_block.children.add_all(defer_triple_stack.top().pop().reverse_vector())
                 }
                 ast_node::for_loop(backing) {
                     loop_stack.pop()
@@ -78,6 +79,10 @@ fun defer_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_t
                 ast_node::while_loop(backing) {
                     loop_stack.pop()
                 }
+                ast_node::function(backing) {
+                    defer_triple_stack.pop()
+                    enclosing_function_stack.pop()
+                }
             }
         }
         run_on_tree(helper_before, helper_after, syntax_ast_pair.second, &visited)
diff --git a/stdlib/obj_lower.krak b/stdlib/obj_lower.krak
index 265b1d0..9c2136c 100644
--- a/stdlib/obj_lower.krak
+++ b/stdlib/obj_lower.krak
@@ -24,6 +24,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
     var visited1 = set<*ast_node>()
     var visited2 = set<*ast_node>()
     var visited3 = set<*ast_node>()
+    var functions_visited_for_construct_in_destruct_out = set<*ast_node>()
     name_ast_map->for_each(fun(name: string, syntax_ast_pair: pair<*tree<symbol>,*ast_node>) {
         // Pass 1
         var ensure_block_and_munge = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
@@ -166,6 +167,12 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
                     }
                 }
                 ast_node::function(backing) {
+                    // Because of how iteration is done now, we might touch functions multiple times (binding-like iteration in a DFS)
+                    // To deal with this, we keep a visited set.
+                    if (functions_visited_for_construct_in_destruct_out.contains(node))
+                        return;
+                    functions_visited_for_construct_in_destruct_out.add(node)
+
                     var order = 0;
                     backing.parameters.for_each(fun(param: *ast_node) {
                         var param_type = get_ast_type(param)
@@ -192,7 +199,6 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
                             backing.expression = null<ast_node>()
                         }
                         if (has_method(ident_type->type_def, "destruct", vector<*type>())) {
-                            // have to go up one because our parent is a statement
                             add_after_in(ast_defer_statement_ptr(make_method_call(backing.identifier, "destruct", vector<*ast_node>())),
                                     node, parent_chain->top())
                         }
diff --git a/stdlib/ref_lower.krak b/stdlib/ref_lower.krak
index 884e386..f6ec29d 100644
--- a/stdlib/ref_lower.krak
+++ b/stdlib/ref_lower.krak
@@ -53,11 +53,8 @@ fun ref_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
                 }
                 ast_node::function(backing) {
                     var full_name = get_fully_scoped_name(node) + " - (" + backing.name + ")"
-                    println("looking at " + full_name + (node) cast int)
-                    if (has_ref_inside(backing.type)) {
+                    if (has_ref_inside(backing.type))
                         remove_ref_type_set.add(make_pair(full_name, backing.type))
-                        println("HAD REF PARAM: ")
-                    }
                 }
                 ast_node::function_call(backing) {
                     // check to see if it's taking a ref, if so add in the &
@@ -80,9 +77,9 @@ fun ref_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
     })
     remove_ref_type_set.for_each(fun(p: pair<string, *type>) {
         var t = p.second
-        println("before" + p.first + ": " + t->to_string())
+        /*println("before" + p.first + ": " + t->to_string())*/
         remove_ref(t)
-        println("after" + p.first + ": " + t->to_string())
+        /*println("after" + p.first + ": " + t->to_string())*/
     })
     modify_reference_use_set.for_each(fun(p: pair<*ast_node, *ast_node>) {
         // if we haven't modified it's indirection yet
@@ -91,8 +88,8 @@ fun ref_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
             p.first->identifier.type = p.first->identifier.type->clone_with_increased_indirection(1, false);
         }
         // note that we definitly want to replace the type for unused parameters, but we don't want to add the * for paramters
-        // in function declarations or declaration statements
-        if (!is_identifier(p.first) || (!is_function(p.second) && !is_declaration_statement(p.second)))
+        // in function declarations or the new identifier in declaration statements (but we do for expressions in declaration statements)
+        if (!is_identifier(p.first) || (!is_function(p.second) && (!is_declaration_statement(p.second) || p.second->declaration_statement.identifier != p.first)))
             replace_with_in(p.first, make_operator_call("*", vector(p.first)), p.second);
     })
     modify_return_set.for_each(fun(r: *ast_node) {