diff --git a/Cargo.lock b/Cargo.lock
index 86146ba..ee62af3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -196,6 +196,7 @@ dependencies = [
  "rand",
  "serde",
  "serde_json",
+ "smallvec",
 ]
 
 [[package]]
@@ -486,6 +487,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.8"
diff --git a/README.md b/README.md
index 283488c..ea6ad90 100644
--- a/README.md
+++ b/README.md
@@ -121,8 +121,9 @@ assigning each argument a register and associating the register with the local.
 
 When generating instructions for a register-based virtual machine, there are opportunities to
 optimize the generated code by using fewer instructions or fewer registers. While it is best to
-output optimal code in the first place, it is not always possible. Dust's compiler uses simple
-functions that modify isolated sections of the instruction list through a mutable reference.
+output optimal code in the first place, it is not always possible. Dust's compiler modifies the
+instruction list during parsing to apply optimizations before the chunk is completed. There is no
+separate optimization pass, and the compiler cannot be run in a mode that disables optimizations.
 
 #### Type Checking
 
diff --git a/bench/assets/count_to_one_billion.ds b/bench/assets/count_to_one_billion.ds
new file mode 100644
index 0000000..8e4c8a5
--- /dev/null
+++ b/bench/assets/count_to_one_billion.ds
@@ -0,0 +1,5 @@
+let mut i = 0
+
+while i < 100_000_000 {
+    i += 1
+}
diff --git a/bench/assets/count_to_one_billion.js b/bench/assets/count_to_one_billion.js
new file mode 100644
index 0000000..998aedd
--- /dev/null
+++ b/bench/assets/count_to_one_billion.js
@@ -0,0 +1,5 @@
+var i = 0;
+
+while (i < 1_000_000_000) {
+  i++;
+}
diff --git a/examples/assets/fibonacci.js b/bench/assets/fibonacci.js
similarity index 100%
rename from examples/assets/fibonacci.js
rename to bench/assets/fibonacci.js
diff --git a/examples/assets/fibonacci.py b/bench/assets/fibonacci.py
similarity index 100%
rename from examples/assets/fibonacci.py
rename to bench/assets/fibonacci.py
diff --git a/dust-lang/Cargo.toml b/dust-lang/Cargo.toml
index c8598d4..e983b81 100644
--- a/dust-lang/Cargo.toml
+++ b/dust-lang/Cargo.toml
@@ -18,6 +18,7 @@ serde_json = "1.0.117"
 getrandom = { version = "0.2", features = [
     "js",
 ] } # Indirect dependency, for wasm builds
+smallvec = { version = "1.13.2", features = ["serde"] }
 
 [dev-dependencies]
 env_logger = "0.11.5"
diff --git a/dust-lang/src/chunk.rs b/dust-lang/src/chunk.rs
index 13d5b3a..a603a2e 100644
--- a/dust-lang/src/chunk.rs
+++ b/dust-lang/src/chunk.rs
@@ -7,6 +7,7 @@
 use std::fmt::{self, Debug, Display, Write};
 
 use serde::{Deserialize, Serialize};
+use smallvec::SmallVec;
 
 use crate::{ConcreteValue, Disassembler, FunctionType, Instruction, Scope, Span, Type};
 
@@ -18,18 +19,18 @@ pub struct Chunk {
     name: Option<String>,
     r#type: FunctionType,
 
-    instructions: Vec<(Instruction, Span)>,
-    constants: Vec<ConcreteValue>,
-    locals: Vec<Local>,
+    instructions: SmallVec<[(Instruction, Span); 32]>,
+    constants: SmallVec<[ConcreteValue; 16]>,
+    locals: SmallVec<[Local; 8]>,
 }
 
 impl Chunk {
     pub fn new(name: Option<String>) -> Self {
         Self {
             name,
-            instructions: Vec::new(),
-            constants: Vec::new(),
-            locals: Vec::new(),
+            instructions: SmallVec::new(),
+            constants: SmallVec::new(),
+            locals: SmallVec::new(),
             r#type: FunctionType {
                 type_parameters: None,
                 value_parameters: None,
@@ -48,9 +49,9 @@ impl Chunk {
         Self {
             name,
             r#type,
-            instructions,
-            constants,
-            locals,
+            instructions: instructions.into(),
+            constants: constants.into(),
+            locals: locals.into(),
         }
     }
 
@@ -70,18 +71,32 @@ impl Chunk {
         self.instructions.is_empty()
     }
 
-    pub fn constants(&self) -> &Vec<ConcreteValue> {
+    pub fn constants(&self) -> &SmallVec<[ConcreteValue; 16]> {
         &self.constants
     }
 
-    pub fn instructions(&self) -> &Vec<(Instruction, Span)> {
+    pub fn instructions(&self) -> &SmallVec<[(Instruction, Span); 32]> {
         &self.instructions
     }
 
-    pub fn locals(&self) -> &Vec<Local> {
+    pub fn locals(&self) -> &SmallVec<[Local; 8]> {
         &self.locals
     }
 
+    pub fn stack_size(&self) -> usize {
+        self.instructions()
+            .iter()
+            .rev()
+            .find_map(|(instruction, _)| {
+                if instruction.yields_value() {
+                    Some(instruction.a() as usize)
+                } else {
+                    None
+                }
+            })
+            .unwrap_or(0)
+    }
+
     pub fn disassembler(&self) -> Disassembler {
         Disassembler::new(self)
     }
diff --git a/dust-lang/src/compiler.rs b/dust-lang/src/compiler.rs
index 56d9360..8d8e1ef 100644
--- a/dust-lang/src/compiler.rs
+++ b/dust-lang/src/compiler.rs
@@ -505,13 +505,19 @@ impl<'src> Compiler<'src> {
         if let Token::Integer(text) = self.current_token {
             self.advance()?;
 
-            let integer = text
-                .parse::<i64>()
-                .map_err(|error| CompileError::ParseIntError {
-                    error,
-                    position: self.previous_position,
-                })?;
-            let value = ConcreteValue::Integer(integer);
+            let mut integer_value = 0_i64;
+
+            for digit in text.chars() {
+                let digit = if let Some(digit) = digit.to_digit(10) {
+                    digit as i64
+                } else {
+                    continue;
+                };
+
+                integer_value = integer_value * 10 + digit;
+            }
+
+            let value = ConcreteValue::Integer(integer_value);
 
             self.emit_constant(value, position)?;
 
@@ -1519,7 +1525,7 @@ impl<'src> Compiler<'src> {
         self.current_position = function_compiler.current_position;
 
         let function =
-            ConcreteValue::Function(function_compiler.finish(None, value_parameters.clone()));
+            ConcreteValue::function(function_compiler.finish(None, value_parameters.clone()));
         let constant_index = self.push_or_get_constant(function);
         let register = self.next_register();
         let function_type = FunctionType {
diff --git a/dust-lang/src/lexer.rs b/dust-lang/src/lexer.rs
index 5a0aad8..b5056a6 100644
--- a/dust-lang/src/lexer.rs
+++ b/dust-lang/src/lexer.rs
@@ -239,7 +239,7 @@ impl<'src> Lexer<'src> {
                 }
             }
 
-            if c.is_ascii_digit() {
+            if c.is_ascii_digit() || c == '_' {
                 self.next_char();
             } else {
                 break;
diff --git a/dust-lang/src/value/abstract_value.rs b/dust-lang/src/value/abstract_value.rs
index 6d59096..5eb1bcf 100644
--- a/dust-lang/src/value/abstract_value.rs
+++ b/dust-lang/src/value/abstract_value.rs
@@ -19,7 +19,7 @@ impl AbstractValue {
 
     pub fn to_concrete_owned(&self, vm: &Vm) -> Result<ConcreteValue, VmError> {
         match self {
-            AbstractValue::FunctionSelf => Ok(ConcreteValue::Function(vm.chunk().clone())),
+            AbstractValue::FunctionSelf => Ok(ConcreteValue::function(vm.chunk().clone())),
             AbstractValue::List { items, .. } => {
                 let mut resolved_items = Vec::with_capacity(items.len());
 
diff --git a/dust-lang/src/value/concrete_value.rs b/dust-lang/src/value/concrete_value.rs
index 88dc768..3b3de31 100644
--- a/dust-lang/src/value/concrete_value.rs
+++ b/dust-lang/src/value/concrete_value.rs
@@ -12,7 +12,7 @@ pub enum ConcreteValue {
     Byte(u8),
     Character(char),
     Float(f64),
-    Function(Chunk),
+    Function(Box<Chunk>),
     Integer(i64),
     List(Vec<ConcreteValue>),
     Range(RangeValue),
@@ -28,6 +28,10 @@ impl ConcreteValue {
         ValueRef::Concrete(self)
     }
 
+    pub fn function(chunk: Chunk) -> Self {
+        ConcreteValue::Function(Box::new(chunk))
+    }
+
     pub fn list<T: Into<Vec<ConcreteValue>>>(into_list: T) -> Self {
         ConcreteValue::List(into_list.into())
     }
diff --git a/dust-lang/src/value/mod.rs b/dust-lang/src/value/mod.rs
index 5d8b04a..47079f9 100644
--- a/dust-lang/src/value/mod.rs
+++ b/dust-lang/src/value/mod.rs
@@ -80,7 +80,7 @@ impl ValueRef<'_> {
     pub fn add(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.add(right).map(|result| result.to_value())
+                left.add(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotAdd(self.to_owned(), other.to_owned())),
         }
@@ -89,7 +89,7 @@ impl ValueRef<'_> {
     pub fn subtract(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.subtract(right).map(|result| result.to_value())
+                left.subtract(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotSubtract(
                 self.to_owned(),
@@ -101,7 +101,7 @@ impl ValueRef<'_> {
     pub fn multiply(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.multiply(right).map(|result| result.to_value())
+                left.multiply(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotMultiply(
                 self.to_owned(),
@@ -113,7 +113,7 @@ impl ValueRef<'_> {
     pub fn divide(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.divide(right).map(|result| result.to_value())
+                left.divide(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotDivide(self.to_owned(), other.to_owned())),
         }
@@ -122,7 +122,7 @@ impl ValueRef<'_> {
     pub fn modulo(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.modulo(right).map(|result| result.to_value())
+                left.modulo(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotModulo(self.to_owned(), other.to_owned())),
         }
@@ -130,18 +130,14 @@ impl ValueRef<'_> {
 
     pub fn negate(&self) -> Result<Value, ValueError> {
         match self {
-            ValueRef::Concrete(concrete_value) => {
-                concrete_value.negate().map(|result| result.to_value())
-            }
+            ValueRef::Concrete(concrete_value) => concrete_value.negate().map(Value::Concrete),
             _ => Err(ValueError::CannotNegate(self.to_owned())),
         }
     }
 
     pub fn not(&self) -> Result<Value, ValueError> {
         match self {
-            ValueRef::Concrete(concrete_value) => {
-                concrete_value.not().map(|result| result.to_value())
-            }
+            ValueRef::Concrete(concrete_value) => concrete_value.not().map(Value::Concrete),
             _ => Err(ValueError::CannotNot(self.to_owned())),
         }
     }
@@ -149,7 +145,7 @@ impl ValueRef<'_> {
     pub fn equal(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.equal(right).map(|result| result.to_value())
+                left.equal(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotCompare(self.to_owned(), other.to_owned())),
         }
@@ -158,7 +154,7 @@ impl ValueRef<'_> {
     pub fn less_than(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
             (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
-                left.less_than(right).map(|result| result.to_value())
+                left.less_than(right).map(Value::Concrete)
             }
             _ => Err(ValueError::CannotCompare(self.to_owned(), other.to_owned())),
         }
@@ -166,9 +162,9 @@ impl ValueRef<'_> {
 
     pub fn less_than_or_equal(&self, other: ValueRef) -> Result<Value, ValueError> {
         match (self, other) {
-            (ValueRef::Concrete(left), ValueRef::Concrete(right)) => left
-                .less_than_or_equal(right)
-                .map(|result| result.to_value()),
+            (ValueRef::Concrete(left), ValueRef::Concrete(right)) => {
+                left.less_than_or_equal(right).map(Value::Concrete)
+            }
             _ => Err(ValueError::CannotCompare(self.to_owned(), other.to_owned())),
         }
     }
diff --git a/dust-lang/src/vm.rs b/dust-lang/src/vm.rs
index e713479..518c7d4 100644
--- a/dust-lang/src/vm.rs
+++ b/dust-lang/src/vm.rs
@@ -5,6 +5,8 @@ use std::{
     io,
 };
 
+use smallvec::{smallvec, SmallVec};
+
 use crate::{
     compile, instruction::*, AbstractValue, AnnotatedError, Argument, Chunk, ConcreteValue,
     Destination, DustError, Instruction, NativeFunctionError, Operation, Span, Value, ValueError,
@@ -25,9 +27,9 @@ pub fn run(source: &str) -> Result<Option<ConcreteValue>, DustError> {
 #[derive(Debug)]
 pub struct Vm<'a> {
     chunk: &'a Chunk,
-    stack: Vec<Register>,
+    stack: SmallVec<[Register; 64]>,
     parent: Option<&'a Vm<'a>>,
-    local_definitions: Vec<Option<u16>>,
+    local_definitions: SmallVec<[Option<u16>; 16]>,
 
     ip: usize,
     last_assigned_register: Option<u16>,
@@ -35,14 +37,14 @@ pub struct Vm<'a> {
 }
 
 impl<'a> Vm<'a> {
-    const STACK_LIMIT: usize = u16::MAX as usize;
+    const STACK_LIMIT: u16 = u16::MAX;
 
     pub fn new(chunk: &'a Chunk, parent: Option<&'a Vm<'a>>) -> Self {
         Self {
             chunk,
-            stack: Vec::new(),
+            stack: smallvec![Register::Empty; chunk.stack_size()],
             parent,
-            local_definitions: vec![None; chunk.locals().len()],
+            local_definitions: smallvec![None; chunk.locals().len()],
             ip: 0,
             last_assigned_register: None,
             current_position: Span(0, 0),
@@ -643,11 +645,9 @@ impl<'a> Vm<'a> {
         Ok(value_ref)
     }
 
+    #[inline(always)]
     fn set_register(&mut self, to_register: u16, register: Register) -> Result<(), VmError> {
-        self.last_assigned_register = Some(to_register);
-
-        let length = self.stack.len();
-        let to_register = to_register as usize;
+        let length = self.stack.len() as u16;
 
         if length == Self::STACK_LIMIT {
             return Err(VmError::StackOverflow {
@@ -659,16 +659,12 @@ impl<'a> Vm<'a> {
             Ordering::Less => {
                 log::trace!("Change R{to_register} to {register}");
 
-                self.stack[to_register] = register;
-
-                Ok(())
+                self.stack[to_register as usize] = register;
             }
             Ordering::Equal => {
                 log::trace!("Set R{to_register} to {register}");
 
                 self.stack.push(register);
-
-                Ok(())
             }
             Ordering::Greater => {
                 let difference = to_register - length;
@@ -682,10 +678,12 @@ impl<'a> Vm<'a> {
                 log::trace!("Set R{to_register} to {register}");
 
                 self.stack.push(register);
-
-                Ok(())
             }
         }
+
+        self.last_assigned_register = Some(to_register);
+
+        Ok(())
     }
 
     fn get_constant(&self, constant_index: u16) -> Result<&ConcreteValue, VmError> {
diff --git a/dust-lang/tests/functions.rs b/dust-lang/tests/functions.rs
index 9a46ed9..5002201 100644
--- a/dust-lang/tests/functions.rs
+++ b/dust-lang/tests/functions.rs
@@ -6,7 +6,7 @@ fn function() {
 
     assert_eq!(
         run(source),
-        Ok(Some(ConcreteValue::Function(Chunk::with_data(
+        Ok(Some(ConcreteValue::function(Chunk::with_data(
             None,
             FunctionType {
                 type_parameters: None,
@@ -70,7 +70,7 @@ fn function_call() {
                 (Instruction::r#return(true), Span(41, 41)),
             ],
             vec![
-                ConcreteValue::Function(Chunk::with_data(
+                ConcreteValue::function(Chunk::with_data(
                     None,
                     FunctionType {
                         type_parameters: None,
@@ -126,7 +126,7 @@ fn function_declaration() {
                 (Instruction::r#return(false), Span(40, 40))
             ],
             vec![
-                ConcreteValue::Function(Chunk::with_data(
+                ConcreteValue::function(Chunk::with_data(
                     Some("add".to_string()),
                     FunctionType {
                         type_parameters: None,
diff --git a/examples/assets/count.js b/examples/assets/count.js
deleted file mode 100644
index ba97d27..0000000
--- a/examples/assets/count.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var i = 0;
-
-while (i < 10000) {
-  i++;
-}
diff --git a/flamegraph.svg b/flamegraph.svg
new file mode 100644
index 0000000..3813bf2
--- /dev/null
+++ b/flamegraph.svg
@@ -0,0 +1,491 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg version="1.1" width="1200" height="230" onload="init(evt)" viewBox="0 0 1200 230" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:fg="http://github.com/jonhoo/inferno"><!--Flame graph stack visualization. See https://github.com/brendangregg/FlameGraph for latest version, and http://www.brendangregg.com/flamegraphs.html for examples.--><!--NOTES: --><defs><linearGradient id="background" y1="0" y2="1" x1="0" x2="0"><stop stop-color="#eeeeee" offset="5%"/><stop stop-color="#eeeeb0" offset="95%"/></linearGradient></defs><style type="text/css">
+text { font-family:monospace; font-size:12px }
+#title { text-anchor:middle; font-size:17px; }
+#matched { text-anchor:end; }
+#search { text-anchor:end; opacity:0.1; cursor:pointer; }
+#search:hover, #search.show { opacity:1; }
+#subtitle { text-anchor:middle; font-color:rgb(160,160,160); }
+#unzoom { cursor:pointer; }
+#frames > *:hover { stroke:black; stroke-width:0.5; cursor:pointer; }
+.hide { display:none; }
+.parent { opacity:0.5; }
+</style><script type="text/ecmascript"><![CDATA[
+        var nametype = 'Function:';
+        var fontsize = 12;
+        var fontwidth = 0.59;
+        var xpad = 10;
+        var inverted = false;
+        var searchcolor = 'rgb(230,0,230)';
+        var fluiddrawing = true;
+        var truncate_text_right = false;
+    ]]><![CDATA["use strict";
+var details, searchbtn, unzoombtn, matchedtxt, svg, searching, frames, known_font_width;
+function init(evt) {
+    details = document.getElementById("details").firstChild;
+    searchbtn = document.getElementById("search");
+    unzoombtn = document.getElementById("unzoom");
+    matchedtxt = document.getElementById("matched");
+    svg = document.getElementsByTagName("svg")[0];
+    frames = document.getElementById("frames");
+    known_font_width = get_monospace_width(frames);
+    total_samples = parseInt(frames.attributes.total_samples.value);
+    searching = 0;
+
+    // Use GET parameters to restore a flamegraph's state.
+    var restore_state = function() {
+        var params = get_params();
+        if (params.x && params.y)
+            zoom(find_group(document.querySelector('[*|x="' + params.x + '"][y="' + params.y + '"]')));
+        if (params.s)
+            search(params.s);
+    };
+
+    if (fluiddrawing) {
+        // Make width dynamic so the SVG fits its parent's width.
+        svg.removeAttribute("width");
+        // Edge requires us to have a viewBox that gets updated with size changes.
+        var isEdge = /Edge\/\d./i.test(navigator.userAgent);
+        if (!isEdge) {
+            svg.removeAttribute("viewBox");
+        }
+        var update_for_width_change = function() {
+            if (isEdge) {
+                svg.attributes.viewBox.value = "0 0 " + svg.width.baseVal.value + " " + svg.height.baseVal.value;
+            }
+
+            // Keep consistent padding on left and right of frames container.
+            frames.attributes.width.value = svg.width.baseVal.value - xpad * 2;
+
+            // Text truncation needs to be adjusted for the current width.
+            update_text_for_elements(frames.children);
+
+            // Keep search elements at a fixed distance from right edge.
+            var svgWidth = svg.width.baseVal.value;
+            searchbtn.attributes.x.value = svgWidth - xpad;
+            matchedtxt.attributes.x.value = svgWidth - xpad;
+        };
+        window.addEventListener('resize', function() {
+            update_for_width_change();
+        });
+        // This needs to be done asynchronously for Safari to work.
+        setTimeout(function() {
+            unzoom();
+            update_for_width_change();
+            restore_state();
+        }, 0);
+    } else {
+        restore_state();
+    }
+}
+// event listeners
+window.addEventListener("click", function(e) {
+    var target = find_group(e.target);
+    if (target) {
+        if (target.nodeName == "a") {
+            if (e.ctrlKey === false) return;
+            e.preventDefault();
+        }
+        if (target.classList.contains("parent")) unzoom();
+        zoom(target);
+
+        // set parameters for zoom state
+        var el = target.querySelector("rect");
+        if (el && el.attributes && el.attributes.y && el.attributes["fg:x"]) {
+            var params = get_params()
+            params.x = el.attributes["fg:x"].value;
+            params.y = el.attributes.y.value;
+            history.replaceState(null, null, parse_params(params));
+        }
+    }
+    else if (e.target.id == "unzoom") {
+        unzoom();
+
+        // remove zoom state
+        var params = get_params();
+        if (params.x) delete params.x;
+        if (params.y) delete params.y;
+        history.replaceState(null, null, parse_params(params));
+    }
+    else if (e.target.id == "search") search_prompt();
+}, false)
+// mouse-over for info
+// show
+window.addEventListener("mouseover", function(e) {
+    var target = find_group(e.target);
+    if (target) details.nodeValue = nametype + " " + g_to_text(target);
+}, false)
+// clear
+window.addEventListener("mouseout", function(e) {
+    var target = find_group(e.target);
+    if (target) details.nodeValue = ' ';
+}, false)
+// ctrl-F for search
+window.addEventListener("keydown",function (e) {
+    if (e.keyCode === 114 || (e.ctrlKey && e.keyCode === 70)) {
+        e.preventDefault();
+        search_prompt();
+    }
+}, false)
+// functions
+function get_params() {
+    var params = {};
+    var paramsarr = window.location.search.substr(1).split('&');
+    for (var i = 0; i < paramsarr.length; ++i) {
+        var tmp = paramsarr[i].split("=");
+        if (!tmp[0] || !tmp[1]) continue;
+        params[tmp[0]]  = decodeURIComponent(tmp[1]);
+    }
+    return params;
+}
+function parse_params(params) {
+    var uri = "?";
+    for (var key in params) {
+        uri += key + '=' + encodeURIComponent(params[key]) + '&';
+    }
+    if (uri.slice(-1) == "&")
+        uri = uri.substring(0, uri.length - 1);
+    if (uri == '?')
+        uri = window.location.href.split('?')[0];
+    return uri;
+}
+function find_child(node, selector) {
+    var children = node.querySelectorAll(selector);
+    if (children.length) return children[0];
+    return;
+}
+function find_group(node) {
+    var parent = node.parentElement;
+    if (!parent) return;
+    if (parent.id == "frames") return node;
+    return find_group(parent);
+}
+function orig_save(e, attr, val) {
+    if (e.attributes["fg:orig_" + attr] != undefined) return;
+    if (e.attributes[attr] == undefined) return;
+    if (val == undefined) val = e.attributes[attr].value;
+    e.setAttribute("fg:orig_" + attr, val);
+}
+function orig_load(e, attr) {
+    if (e.attributes["fg:orig_"+attr] == undefined) return;
+    e.attributes[attr].value = e.attributes["fg:orig_" + attr].value;
+    e.removeAttribute("fg:orig_" + attr);
+}
+function g_to_text(e) {
+    var text = find_child(e, "title").firstChild.nodeValue;
+    return (text)
+}
+function g_to_func(e) {
+    var func = g_to_text(e);
+    // if there's any manipulation we want to do to the function
+    // name before it's searched, do it here before returning.
+    return (func);
+}
+function get_monospace_width(frames) {
+    // Given the id="frames" element, return the width of text characters if
+    // this is a monospace font, otherwise return 0.
+    text = find_child(frames.children[0], "text");
+    originalContent = text.textContent;
+    text.textContent = "!";
+    bangWidth = text.getComputedTextLength();
+    text.textContent = "W";
+    wWidth = text.getComputedTextLength();
+    text.textContent = originalContent;
+    if (bangWidth === wWidth) {
+        return bangWidth;
+    } else {
+        return 0;
+    }
+}
+function update_text_for_elements(elements) {
+    // In order to render quickly in the browser, you want to do one pass of
+    // reading attributes, and one pass of mutating attributes. See
+    // https://web.dev/avoid-large-complex-layouts-and-layout-thrashing/ for details.
+
+    // Fall back to inefficient calculation, if we're variable-width font.
+    // TODO This should be optimized somehow too.
+    if (known_font_width === 0) {
+        for (var i = 0; i < elements.length; i++) {
+            update_text(elements[i]);
+        }
+        return;
+    }
+
+    var textElemNewAttributes = [];
+    for (var i = 0; i < elements.length; i++) {
+        var e = elements[i];
+        var r = find_child(e, "rect");
+        var t = find_child(e, "text");
+        var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
+        var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
+        var newX = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
+
+        // Smaller than this size won't fit anything
+        if (w < 2 * known_font_width) {
+            textElemNewAttributes.push([newX, ""]);
+            continue;
+        }
+
+        // Fit in full text width
+        if (txt.length * known_font_width < w) {
+            textElemNewAttributes.push([newX, txt]);
+            continue;
+        }
+
+        var substringLength = Math.floor(w / known_font_width) - 2;
+        if (truncate_text_right) {
+            // Truncate the right side of the text.
+            textElemNewAttributes.push([newX, txt.substring(0, substringLength) + ".."]);
+            continue;
+        } else {
+            // Truncate the left side of the text.
+            textElemNewAttributes.push([newX, ".." + txt.substring(txt.length - substringLength, txt.length)]);
+            continue;
+        }
+    }
+
+    console.assert(textElemNewAttributes.length === elements.length, "Resize failed, please file a bug at https://github.com/jonhoo/inferno/");
+
+    // Now that we know new textContent, set it all in one go so we don't refresh a bazillion times.
+    for (var i = 0; i < elements.length; i++) {
+        var e = elements[i];
+        var values = textElemNewAttributes[i];
+        var t = find_child(e, "text");
+        t.attributes.x.value = values[0];
+        t.textContent = values[1];
+    }
+}
+
+function update_text(e) {
+    var r = find_child(e, "rect");
+    var t = find_child(e, "text");
+    var w = parseFloat(r.attributes.width.value) * frames.attributes.width.value / 100 - 3;
+    var txt = find_child(e, "title").textContent.replace(/\([^(]*\)$/,"");
+    t.attributes.x.value = format_percent((parseFloat(r.attributes.x.value) + (100 * 3 / frames.attributes.width.value)));
+
+    // Smaller than this size won't fit anything
+    if (w < 2 * fontsize * fontwidth) {
+        t.textContent = "";
+        return;
+    }
+    t.textContent = txt;
+    // Fit in full text width
+    if (t.getComputedTextLength() < w)
+        return;
+    if (truncate_text_right) {
+        // Truncate the right side of the text.
+        for (var x = txt.length - 2; x > 0; x--) {
+            if (t.getSubStringLength(0, x + 2) <= w) {
+                t.textContent = txt.substring(0, x) + "..";
+                return;
+            }
+        }
+    } else {
+        // Truncate the left side of the text.
+        for (var x = 2; x < txt.length; x++) {
+            if (t.getSubStringLength(x - 2, txt.length) <= w) {
+                t.textContent = ".." + txt.substring(x, txt.length);
+                return;
+            }
+        }
+    }
+    t.textContent = "";
+}
+// zoom
+function zoom_reset(e) {
+    if (e.tagName == "rect") {
+        e.attributes.x.value = format_percent(100 * parseInt(e.attributes["fg:x"].value) / total_samples);
+        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / total_samples);
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_reset(c[i]);
+    }
+}
+function zoom_child(e, x, zoomed_width_samples) {
+    if (e.tagName == "text") {
+        var parent_x = parseFloat(find_child(e.parentNode, "rect[x]").attributes.x.value);
+        e.attributes.x.value = format_percent(parent_x + (100 * 3 / frames.attributes.width.value));
+    } else if (e.tagName == "rect") {
+        e.attributes.x.value = format_percent(100 * (parseInt(e.attributes["fg:x"].value) - x) / zoomed_width_samples);
+        e.attributes.width.value = format_percent(100 * parseInt(e.attributes["fg:w"].value) / zoomed_width_samples);
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_child(c[i], x, zoomed_width_samples);
+    }
+}
+function zoom_parent(e) {
+    if (e.attributes) {
+        if (e.attributes.x != undefined) {
+            e.attributes.x.value = "0.0%";
+        }
+        if (e.attributes.width != undefined) {
+            e.attributes.width.value = "100.0%";
+        }
+    }
+    if (e.childNodes == undefined) return;
+    for(var i = 0, c = e.childNodes; i < c.length; i++) {
+        zoom_parent(c[i]);
+    }
+}
+function zoom(node) {
+    var attr = find_child(node, "rect").attributes;
+    var width = parseInt(attr["fg:w"].value);
+    var xmin = parseInt(attr["fg:x"].value);
+    var xmax = xmin + width;
+    var ymin = parseFloat(attr.y.value);
+    unzoombtn.classList.remove("hide");
+    var el = frames.children;
+    var to_update_text = [];
+    for (var i = 0; i < el.length; i++) {
+        var e = el[i];
+        var a = find_child(e, "rect").attributes;
+        var ex = parseInt(a["fg:x"].value);
+        var ew = parseInt(a["fg:w"].value);
+        // Is it an ancestor
+        if (!inverted) {
+            var upstack = parseFloat(a.y.value) > ymin;
+        } else {
+            var upstack = parseFloat(a.y.value) < ymin;
+        }
+        if (upstack) {
+            // Direct ancestor
+            if (ex <= xmin && (ex+ew) >= xmax) {
+                e.classList.add("parent");
+                zoom_parent(e);
+                to_update_text.push(e);
+            }
+            // not in current path
+            else
+                e.classList.add("hide");
+        }
+        // Children maybe
+        else {
+            // no common path
+            if (ex < xmin || ex >= xmax) {
+                e.classList.add("hide");
+            }
+            else {
+                zoom_child(e, xmin, width);
+                to_update_text.push(e);
+            }
+        }
+    }
+    update_text_for_elements(to_update_text);
+}
+function unzoom() {
+    unzoombtn.classList.add("hide");
+    var el = frames.children;
+    for(var i = 0; i < el.length; i++) {
+        el[i].classList.remove("parent");
+        el[i].classList.remove("hide");
+        zoom_reset(el[i]);
+    }
+    update_text_for_elements(el);
+}
+// search
+function reset_search() {
+    var el = document.querySelectorAll("#frames rect");
+    for (var i = 0; i < el.length; i++) {
+        orig_load(el[i], "fill")
+    }
+    var params = get_params();
+    delete params.s;
+    history.replaceState(null, null, parse_params(params));
+}
+function search_prompt() {
+    if (!searching) {
+        var term = prompt("Enter a search term (regexp " +
+            "allowed, eg: ^ext4_)", "");
+        if (term != null) {
+            search(term)
+        }
+    } else {
+        reset_search();
+        searching = 0;
+        searchbtn.classList.remove("show");
+        searchbtn.firstChild.nodeValue = "Search"
+        matchedtxt.classList.add("hide");
+        matchedtxt.firstChild.nodeValue = ""
+    }
+}
+function search(term) {
+    var re = new RegExp(term);
+    var el = frames.children;
+    var matches = new Object();
+    var maxwidth = 0;
+    for (var i = 0; i < el.length; i++) {
+        var e = el[i];
+        // Skip over frames which are either not visible, or below the zoomed-to frame
+        if (e.classList.contains("hide") || e.classList.contains("parent")) {
+            continue;
+        }
+        var func = g_to_func(e);
+        var rect = find_child(e, "rect");
+        if (func == null || rect == null)
+            continue;
+        // Save max width. Only works as we have a root frame
+        var w = parseInt(rect.attributes["fg:w"].value);
+        if (w > maxwidth)
+            maxwidth = w;
+        if (func.match(re)) {
+            // highlight
+            var x = parseInt(rect.attributes["fg:x"].value);
+            orig_save(rect, "fill");
+            rect.attributes.fill.value = searchcolor;
+            // remember matches
+            if (matches[x] == undefined) {
+                matches[x] = w;
+            } else {
+                if (w > matches[x]) {
+                    // overwrite with parent
+                    matches[x] = w;
+                }
+            }
+            searching = 1;
+        }
+    }
+    if (!searching)
+        return;
+    var params = get_params();
+    params.s = term;
+    history.replaceState(null, null, parse_params(params));
+
+    searchbtn.classList.add("show");
+    searchbtn.firstChild.nodeValue = "Reset Search";
+    // calculate percent matched, excluding vertical overlap
+    var count = 0;
+    var lastx = -1;
+    var lastw = 0;
+    var keys = Array();
+    for (k in matches) {
+        if (matches.hasOwnProperty(k))
+            keys.push(k);
+    }
+    // sort the matched frames by their x location
+    // ascending, then width descending
+    keys.sort(function(a, b){
+        return a - b;
+    });
+    // Step through frames saving only the biggest bottom-up frames
+    // thanks to the sort order. This relies on the tree property
+    // where children are always smaller than their parents.
+    for (var k in keys) {
+        var x = parseInt(keys[k]);
+        var w = matches[keys[k]];
+        if (x >= lastx + lastw) {
+            count += w;
+            lastx = x;
+            lastw = w;
+        }
+    }
+    // display matched percent
+    matchedtxt.classList.remove("hide");
+    var pct = 100 * count / maxwidth;
+    if (pct != 100) pct = pct.toFixed(1);
+    matchedtxt.firstChild.nodeValue = "Matched: " + pct + "%";
+}
+function format_percent(n) {
+    return n.toFixed(4) + "%";
+}
+]]></script><rect x="0" y="0" width="100%" height="230" fill="url(#background)"/><text id="title" fill="rgb(0,0,0)" x="50.0000%" y="24.00">Flame Graph</text><text id="details" fill="rgb(0,0,0)" x="10" y="213.00"> </text><text id="unzoom" class="hide" fill="rgb(0,0,0)" x="10" y="24.00">Reset Zoom</text><text id="search" fill="rgb(0,0,0)" x="1190" y="24.00">Search</text><text id="matched" fill="rgb(0,0,0)" x="1190" y="213.00"> </text><svg id="frames" x="10" width="1180" total_samples="15711250040"><g><title>&lt;core::result::Result&lt;T,E&gt; as core::ops::try_trait::Try&gt;::branch (1,560,579,007 samples, 9.93%)</title><rect x="0.0019%" y="133" width="9.9329%" height="15" fill="rgb(227,0,7)" fg:x="292680" fg:w="1560579007"/><text x="0.2519%" y="143.50">&lt;core::result:..</text></g><g><title>&lt;dust_lang::instruction::jump::Jump as core::convert::From&lt;&amp;dust_lang::instruction::Instruction&gt;&gt;::from (5,136,709 samples, 0.03%)</title><rect x="9.9347%" y="133" width="0.0327%" height="15" fill="rgb(217,0,24)" fg:x="1560871687" fg:w="5136709"/><text x="10.1847%" y="143.50"></text></g><g><title>dust_lang::instruction::Instruction::b (5,136,709 samples, 0.03%)</title><rect x="9.9347%" y="117" width="0.0327%" height="15" fill="rgb(221,193,54)" fg:x="1560871687" fg:w="5136709"/><text x="10.1847%" y="127.50"></text></g><g><title>core::result::Result&lt;T,E&gt;::map_err (1,922,298,094 samples, 12.24%)</title><rect x="9.9674%" y="133" width="12.2352%" height="15" fill="rgb(248,212,6)" fg:x="1566008397" fg:w="1922298094"/><text x="10.2174%" y="143.50">core::result::Resu..</text></g><g><title>core::result::Result&lt;T,E&gt;::map (2,075,171,161 samples, 13.21%)</title><rect x="22.4651%" y="117" width="13.2082%" height="15" fill="rgb(208,68,35)" fg:x="3529550144" fg:w="2075171161"/><text x="22.7151%" y="127.50">core::result::Result..</text></g><g><title>dust_lang::value::ValueRef::add (5,533,570,295 samples, 35.22%)</title><rect x="22.2026%" y="133" width="35.2204%" height="15" fill="rgb(232,128,0)" fg:x="3488306512" fg:w="5533570295"/><text x="22.4526%" y="143.50">dust_lang::value::ValueRef::add</text></g><g><title>dust_lang::value::concrete_value::ConcreteValue::add (3,417,155,502 samples, 21.75%)</title><rect x="35.6733%" y="117" width="21.7497%" height="15" fill="rgb(207,160,47)" fg:x="5604721305" fg:w="3417155502"/><text x="35.9233%" y="127.50">dust_lang::value::concrete_value::..</text></g><g><title>core::result::Result&lt;T,E&gt;::map (5,053,956,012 samples, 32.17%)</title><rect x="58.6073%" y="117" width="32.1678%" height="15" fill="rgb(228,23,34)" fg:x="9207938847" fg:w="5053956012"/><text x="58.8573%" y="127.50">core::result::Result&lt;T,E&gt;::map</text></g><g><title>[unknown] (5,165,849 samples, 0.03%)</title><rect x="90.7422%" y="101" width="0.0329%" height="15" fill="rgb(218,30,26)" fg:x="14256729010" fg:w="5165849"/><text x="90.9922%" y="111.50"></text></g><g><title>[unknown] (5,165,849 samples, 0.03%)</title><rect x="90.7422%" y="85" width="0.0329%" height="15" fill="rgb(220,122,19)" fg:x="14256729010" fg:w="5165849"/><text x="90.9922%" y="95.50"></text></g><g><title>[unknown] (5,165,849 samples, 0.03%)</title><rect x="90.7422%" y="69" width="0.0329%" height="15" fill="rgb(250,228,42)" fg:x="14256729010" fg:w="5165849"/><text x="90.9922%" y="79.50"></text></g><g><title>[unknown] (5,165,849 samples, 0.03%)</title><rect x="90.7422%" y="53" width="0.0329%" height="15" fill="rgb(240,193,28)" fg:x="14256729010" fg:w="5165849"/><text x="90.9922%" y="63.50"></text></g><g><title>[unknown] (5,165,849 samples, 0.03%)</title><rect x="90.7422%" y="37" width="0.0329%" height="15" fill="rgb(216,20,37)" fg:x="14256729010" fg:w="5165849"/><text x="90.9922%" y="47.50"></text></g><g><title>dust_lang::value::ValueRef::less_than (6,679,061,476 samples, 42.51%)</title><rect x="57.4230%" y="133" width="42.5113%" height="15" fill="rgb(206,188,39)" fg:x="9021876807" fg:w="6679061476"/><text x="57.6730%" y="143.50">dust_lang::value::ValueRef::less_than</text></g><g><title>dust_lang::value::concrete_value::ConcreteValue::less_than (1,439,043,424 samples, 9.16%)</title><rect x="90.7750%" y="117" width="9.1593%" height="15" fill="rgb(217,207,13)" fg:x="14261894859" fg:w="1439043424"/><text x="91.0250%" y="127.50">dust_lang::va..</text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd&lt;&amp;B&gt; for &amp;A&gt;::lt (273,670,000 samples, 1.74%)</title><rect x="98.1925%" y="101" width="1.7419%" height="15" fill="rgb(231,73,38)" fg:x="15427268283" fg:w="273670000"/><text x="98.4425%" y="111.50"></text></g><g><title>core::cmp::impls::&lt;impl core::cmp::PartialOrd for i64&gt;::lt (273,670,000 samples, 1.74%)</title><rect x="98.1925%" y="85" width="1.7419%" height="15" fill="rgb(225,20,46)" fg:x="15427268283" fg:w="273670000"/><text x="98.4425%" y="95.50"></text></g><g><title>dust_lang::vm::Vm::get_argument (5,140,762 samples, 0.03%)</title><rect x="99.9344%" y="133" width="0.0327%" height="15" fill="rgb(210,31,41)" fg:x="15700938283" fg:w="5140762"/><text x="100.1844%" y="143.50"></text></g><g><title>dust_lang::vm::Vm::read (5,169,945 samples, 0.03%)</title><rect x="99.9671%" y="133" width="0.0329%" height="15" fill="rgb(221,200,47)" fg:x="15706079045" fg:w="5169945"/><text x="100.2171%" y="143.50"></text></g><g><title>all (15,711,250,040 samples, 100%)</title><rect x="0.0000%" y="181" width="100.0000%" height="15" fill="rgb(226,26,5)" fg:x="0" fg:w="15711250040"/><text x="0.2500%" y="191.50"></text></g><g><title>dust_lang::vm::run (15,710,957,362 samples, 100.00%)</title><rect x="0.0019%" y="165" width="99.9981%" height="15" fill="rgb(249,33,26)" fg:x="292678" fg:w="15710957362"/><text x="0.2519%" y="175.50">dust_lang::vm::run</text></g><g><title>dust_lang::vm::Vm::run (15,710,957,362 samples, 100.00%)</title><rect x="0.0019%" y="149" width="99.9981%" height="15" fill="rgb(235,183,28)" fg:x="292678" fg:w="15710957362"/><text x="0.2519%" y="159.50">dust_lang::vm::Vm::run</text></g></svg></svg>
\ No newline at end of file
diff --git a/perf.data b/perf.data
new file mode 100644
index 0000000..dc2b963
Binary files /dev/null and b/perf.data differ
diff --git a/perf.data.old b/perf.data.old
new file mode 100644
index 0000000..4886fe9
--- /dev/null
+++ b/perf.data.old
@@ -0,0 +1,22 @@
+# started on Tue Dec  3 23:57:01 2024
+
+
+ Performance counter stats for 'target/release/dust bench/assets/count_to_one_billion.ds':
+
+          3,821.33 msec task-clock:u                     #    1.000 CPUs utilized             
+                 0      context-switches:u               #    0.000 /sec                      
+                 0      cpu-migrations:u                 #    0.000 /sec                      
+               128      page-faults:u                    #   33.496 /sec                      
+    19,568,365,731      cycles:u                         #    5.121 GHz                       
+        22,811,191      stalled-cycles-frontend:u        #    0.12% frontend cycles idle      
+    70,300,518,284      instructions:u                   #    3.59  insn per cycle            
+                                                  #    0.00  stalled cycles per insn   
+    12,500,111,636      branches:u                       #    3.271 G/sec                     
+            19,795      branch-misses:u                  #    0.00% of all branches           
+
+       3.822391878 seconds time elapsed
+
+       3.811230000 seconds user
+       0.000999000 seconds sys
+
+