diff --git a/Cargo.lock b/Cargo.lock
index 0c1fcce0f..0c7b9d2c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1519,9 +1519,9 @@ dependencies = [
 
 [[package]]
 name = "im-lists"
-version = "0.7.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c07eff2c41645923382085ea8627509e5184f7a668f75d0c1e16091f7af4798"
+checksum = "3e7233fb8b1ffc0b1d6033fd311a74a0443164628c62abbc871185ee95098b63"
 dependencies = [
  "smallvec",
 ]
diff --git a/crates/steel-core/Cargo.toml b/crates/steel-core/Cargo.toml
index a41bdfdd7..850e5ec04 100644
--- a/crates/steel-core/Cargo.toml
+++ b/crates/steel-core/Cargo.toml
@@ -26,14 +26,12 @@ serde = { version = "1.0.193", features = ["derive", "rc"] }
 serde_derive = "1.0.193"
 bincode = "1.3.3"
 pretty = "0.12.1"
-im-lists = "0.7.1"
+im-lists = "0.8.0"
 strsim = "0.11.0"
-
 quickscope = "0.2.0"
 lasso = { version = "0.7.2", features = ["multi-threaded", "serialize"] }
 once_cell = "1.18.0"
 fxhash = "0.2.1"
-# lazy_static = "1.4.0"
 steel-gen = { path = "../steel-gen", version = "0.2.0" }
 steel-parser = { path = "../steel-parser", version = "0.6.0" }
 steel-derive = { path = "../steel-derive", version = "0.5.0" }
diff --git a/crates/steel-core/src/compiler/code_gen.rs b/crates/steel-core/src/compiler/code_gen.rs
index 2316c5d6d..ff7e3fabb 100644
--- a/crates/steel-core/src/compiler/code_gen.rs
+++ b/crates/steel-core/src/compiler/code_gen.rs
@@ -36,7 +36,6 @@ use crate::rvals::Result;
 pub(crate) static FUNCTION_ID: AtomicUsize = AtomicUsize::new(0);
 
 fn fresh_function_id() -> usize {
-    // println!("{:?}", FUNCTION_ID);
     FUNCTION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
 }
 
@@ -124,11 +123,11 @@ impl<'a> CodeGenerator<'a> {
         let value = eval_atom(syn)?;
 
         let idx = self.constant_map.add_or_get(value);
+        // First, lets check that the value fits
         self.push(
             LabeledInstruction::builder(OpCode::PUSHCONST)
                 .payload(idx)
-                .contents(syn.clone())
-                .constant(true),
+                .contents(syn.clone()),
         );
         Ok(())
     }
@@ -651,8 +650,7 @@ impl<'a> VisitorMut for CodeGenerator<'a> {
                 // TODO: This is a little suspect, we're doing a bunch of stuff twice
                 // that we really don't need. In fact, we probably can get away with just...
                 // embedding the steel val directly here.
-                .list_contents(crate::parser::ast::ExprKind::Quote(Box::new(quote.clone())))
-                .constant(true),
+                .list_contents(crate::parser::ast::ExprKind::Quote(Box::new(quote.clone()))),
         );
 
         Ok(())
diff --git a/crates/steel-core/src/compiler/program.rs b/crates/steel-core/src/compiler/program.rs
index 6087223bf..13564035a 100644
--- a/crates/steel-core/src/compiler/program.rs
+++ b/crates/steel-core/src/compiler/program.rs
@@ -175,7 +175,7 @@ pub fn convert_call_globals(instructions: &mut [Instruction]) {
 
                 if let TokenType::Identifier(ident) = ident.ty {
                     match ident {
-                        _ if ident == *PRIM_CONS_SYMBOL => {
+                        _ if ident == *PRIM_CONS_SYMBOL && arity == 2 => {
                             if let Some(x) = instructions.get_mut(i) {
                                 x.op_code = OpCode::CONS;
                                 x.payload_size = 2;
@@ -192,34 +192,55 @@ pub fn convert_call_globals(instructions: &mut [Instruction]) {
                         //         continue;
                         //     }
                         // }
-                        _ if ident == *BOX || ident == *PRIM_BOX => {
+                        _ if ident == *BOX || ident == *PRIM_BOX && arity == 1 => {
                             if let Some(x) = instructions.get_mut(i) {
                                 x.op_code = OpCode::NEWBOX;
                                 continue;
                             }
                         }
 
-                        _ if ident == *UNBOX || ident == *PRIM_UNBOX => {
+                        _ if ident == *UNBOX || ident == *PRIM_UNBOX && arity == 1 => {
                             if let Some(x) = instructions.get_mut(i) {
                                 x.op_code = OpCode::UNBOX;
                                 continue;
                             }
                         }
 
-                        _ if ident == *SETBOX || ident == *PRIM_SETBOX => {
+                        _ if ident == *SETBOX || ident == *PRIM_SETBOX && arity == 1 => {
                             if let Some(x) = instructions.get_mut(i) {
                                 x.op_code = OpCode::SETBOX;
                                 continue;
                             }
                         }
 
-                        _ if ident == *PRIM_CAR => {
+                        _ if ident == *PRIM_CAR && arity == 1 => {
                             if let Some(x) = instructions.get_mut(i) {
                                 x.op_code = OpCode::CAR;
                                 continue;
                             }
                         }
 
+                        _ if ident == *PRIM_CDR && arity == 1 => {
+                            if let Some(x) = instructions.get_mut(i) {
+                                x.op_code = OpCode::CDR;
+                                continue;
+                            }
+                        }
+
+                        _ if ident == *PRIM_NOT && arity == 1 => {
+                            if let Some(x) = instructions.get_mut(i) {
+                                x.op_code = OpCode::NOT;
+                                continue;
+                            }
+                        }
+
+                        _ if ident == *PRIM_NULL && arity == 1 => {
+                            if let Some(x) = instructions.get_mut(i) {
+                                x.op_code = OpCode::NULL;
+                                continue;
+                            }
+                        }
+
                         // _ if ident == *CDR_SYMBOL || ident == *PRIM_CAR => {
                         //     if let Some(x) = instructions.get_mut(i) {
                         //         x.op_code = OpCode::CAR;
@@ -347,9 +368,12 @@ define_primitive_symbols! {
     (PRIM_DIV, DIV) => "/",
     (PRIM_STAR, STAR) => "*",
     (PRIM_EQUAL, EQUAL) => "equal?",
+    (PRIM_NUM_EQUAL, NUM_EQUAL) => "=",
     (PRIM_LTE, LTE) => "<=",
     (PRIM_CAR, CAR_SYMBOL) => "car",
     (PRIM_CDR, CDR_SYMBOL) => "cdr",
+    (PRIM_NOT, NOT_SYMBOL) => "not",
+    (PRIM_NULL, NULL_SYMBOL) => "null?",
 }
 
 define_symbols! {
@@ -435,9 +459,11 @@ pub fn inline_num_operations(instructions: &mut [Instruction]) {
             let replaced = match *ident {
                 x if x == *PRIM_PLUS && *payload_size == 2 => Some(OpCode::BINOPADD),
                 x if x == *PRIM_PLUS && *payload_size > 0 => Some(OpCode::ADD),
+                // x if x == *PRIM_MINUS && *payload_size == 2 => Some(OpCode::BINOPSUB),
                 x if x == *PRIM_MINUS && *payload_size > 0 => Some(OpCode::SUB),
                 x if x == *PRIM_DIV && *payload_size > 0 => Some(OpCode::DIV),
                 x if x == *PRIM_STAR && *payload_size > 0 => Some(OpCode::MUL),
+                x if x == *PRIM_NUM_EQUAL && *payload_size == 2 => Some(OpCode::NUMEQUAL),
                 x if x == *PRIM_EQUAL && *payload_size > 0 => Some(OpCode::EQUAL),
                 x if x == *PRIM_LTE && *payload_size > 0 => Some(OpCode::LTE),
                 _ => None,
@@ -1116,9 +1142,8 @@ fn extract_spans(
                     DenseInstruction::new(
                         i.op_code,
                         i.payload_size.try_into().unwrap_or_else(|_| {
-                            // println!("{:?}", len);
                             println!("{:?}", i);
-                            panic!("Uh oh ")
+                            panic!("Unable to lower instruction to bytecode!")
                         }),
                     )
                 })
diff --git a/crates/steel-core/src/core/instructions.rs b/crates/steel-core/src/core/instructions.rs
index 159e39f14..8c7c29645 100644
--- a/crates/steel-core/src/core/instructions.rs
+++ b/crates/steel-core/src/core/instructions.rs
@@ -117,6 +117,8 @@ pub fn disassemble(instructions: &[Instruction]) -> String {
 pub struct DenseInstruction {
     pub op_code: OpCode,
     // Function IDs need to be interned _again_ before patched into the code?
+    // Also: We should be able to get away with a u16 here. Just grab places where u16
+    // won't fit and convert to something else.
     pub payload_size: u32,
 }
 
diff --git a/crates/steel-core/src/core/labels.rs b/crates/steel-core/src/core/labels.rs
index ff2b97da2..801af8e9c 100644
--- a/crates/steel-core/src/core/labels.rs
+++ b/crates/steel-core/src/core/labels.rs
@@ -23,7 +23,7 @@ pub enum Expr {
 }
 
 #[derive(Clone, Debug)]
-pub struct LabeledInstruction {
+pub struct CompactInstruction {
     pub op_code: OpCode,
     pub payload_size: usize,
     pub contents: Option<Expr>,
@@ -32,6 +32,15 @@ pub struct LabeledInstruction {
     pub constant: bool,
 }
 
+#[derive(Clone, Debug)]
+pub struct LabeledInstruction {
+    pub op_code: OpCode,
+    pub payload_size: usize,
+    pub contents: Option<Expr>,
+    pub tag: Option<Label>,
+    pub goto: Option<Label>,
+}
+
 impl LabeledInstruction {
     pub fn builder(op_code: OpCode) -> Self {
         Self {
@@ -40,7 +49,6 @@ impl LabeledInstruction {
             contents: None,
             tag: None,
             goto: None,
-            constant: false,
         }
     }
 
@@ -69,11 +77,6 @@ impl LabeledInstruction {
         self
     }
 
-    pub fn constant(mut self, constant: bool) -> Self {
-        self.constant = constant;
-        self
-    }
-
     pub fn set_goto(&mut self, goto: Label) {
         self.goto = Some(goto);
     }
diff --git a/crates/steel-core/src/env.rs b/crates/steel-core/src/env.rs
index 33581bc05..381a33a86 100644
--- a/crates/steel-core/src/env.rs
+++ b/crates/steel-core/src/env.rs
@@ -38,12 +38,6 @@ impl Env {
         }
     }
 
-    /// Search starting from the current environment
-    /// for `idx`, looking through the parent chain in order.
-    ///
-    /// if found, return that value
-    ///
-    /// Otherwise, error with `FreeIdentifier`
     #[inline(always)]
     pub fn repl_lookup_idx(&self, idx: usize) -> SteelVal {
         self.bindings_vec[idx].clone()
diff --git a/crates/steel-core/src/primitives/lists.rs b/crates/steel-core/src/primitives/lists.rs
index dc2372f6b..3bbc1325a 100644
--- a/crates/steel-core/src/primitives/lists.rs
+++ b/crates/steel-core/src/primitives/lists.rs
@@ -19,16 +19,16 @@ use crate::core::utils::{
 };
 
 declare_const_ref_functions! {
-    REVERSE => reverse,
     LAST => last,
     TRY_LIST_REF => try_list_ref,
     LIST_TO_STRING => steel_list_to_string,
 }
 
 declare_const_mut_ref_functions! {
+    REVERSE => reverse,
     CONS => cons,
     REST => rest,
-    CDR => cdr,
+    CDR => steel_cdr,
     APPEND => append,
     PUSH_BACK => push_back,
 }
@@ -240,7 +240,7 @@ pub fn new(args: &[SteelVal]) -> Result<SteelVal> {
 /// > (empty? '()) ;; => #true
 /// ```
 #[steel_derive::function(name = "empty?")]
-fn is_empty(list: &SteelVal) -> bool {
+pub fn is_empty(list: &SteelVal) -> bool {
     list.list().map(|x| x.is_empty()).unwrap_or_default()
 }
 
@@ -279,7 +279,10 @@ pub fn cons(args: &mut [SteelVal]) -> Result<SteelVal> {
     if args.len() != 2 {
         stop!(ArityMismatch => "cons takes only two arguments")
     }
-    match (args[0].clone(), &mut args[1]) {
+    match (
+        std::mem::replace(&mut args[0], SteelVal::Void),
+        &mut args[1],
+    ) {
         (left, SteelVal::ListV(right)) => {
             right.cons_mut(left);
 
@@ -317,20 +320,15 @@ macro_rules! debug_unreachable {
 // This is really just for use cases where we absolutely, 100% know, that within the body of a function,
 // it is _not possible_ for the value to be anything but a list. Eliding these checks in hot loops
 // can prove to be beneficial.
-// unsafe fn unsafe_cons(args: &mut [SteelVal]) -> SteelVal {
+
+// pub(crate) fn unsafe_cons(args: &mut [SteelVal]) -> Result<SteelVal> {
 //     match (args[0].clone(), &mut args[1]) {
 //         (left, SteelVal::ListV(right)) => {
 //             right.cons_mut(left);
-
 //             // Consider moving in a default value instead of cloning?
-//             SteelVal::ListV(right.clone())
+//             Ok(SteelVal::ListV(right.clone()))
 //         }
-//         _ => debug_unreachable!(),
-//         // Silly, but this then gives us a special "pair" that is different
-//         // from a real bonafide list
-//         // (left, right) => Ok(SteelVal::Pair(Gc::new(Pair::cons(left, right.clone())))),
-//         // TODO: Replace with an immutable pair here!
-//         // (left, right) => Ok(SteelVal::ListV(vec![left, right.clone()].into())),
+//         _ => unsafe { debug_unreachable!() },
 //     }
 // }
 
@@ -386,11 +384,11 @@ This function takes time proportional to the length of lst."#,
     examples: &[("> (reverse (list 1 2 3 4))", "=> '(4 3 2 1)")],
 };
 
-fn reverse(args: &[SteelVal]) -> Result<SteelVal> {
+fn reverse(args: &mut [SteelVal]) -> Result<SteelVal> {
     arity_check!(reverse, args, 1);
 
-    if let SteelVal::ListV(l) = &args[0] {
-        Ok(SteelVal::ListV(l.clone().reverse()))
+    if let SteelVal::ListV(l) = std::mem::replace(&mut args[0], SteelVal::Void) {
+        Ok(SteelVal::ListV(l.reverse()))
     } else {
         stop!(TypeMismatch => "reverse expects a list")
     }
@@ -447,7 +445,7 @@ fn first(list: &List<SteelVal>) -> Result<SteelVal> {
 /// > (car (cons 2 3)) ;; => 2
 /// ```
 #[steel_derive::function(name = "car", constant = true)]
-fn car(list: &SteelVal) -> Result<SteelVal> {
+pub(crate) fn car(list: &SteelVal) -> Result<SteelVal> {
     match list {
         SteelVal::ListV(l) => l
             .car()
@@ -496,24 +494,23 @@ fn cdr_is_null(args: &[SteelVal]) -> Result<SteelVal> {
     }
 }
 
-fn cdr(args: &mut [SteelVal]) -> Result<SteelVal> {
-    arity_check!(rest, args, 1);
-
-    match &mut args[0] {
-        SteelVal::ListV(l) => {
+#[steel_derive::function(name = "cdr", constant = true)]
+pub(crate) fn cdr(arg: &mut SteelVal) -> Result<SteelVal> {
+    match std::mem::replace(arg, SteelVal::Void) {
+        SteelVal::ListV(mut l) => {
             if l.is_empty() {
                 stop!(Generic => "cdr expects a non empty list");
             }
 
             match l.rest_mut() {
-                Some(l) => Ok(SteelVal::ListV(l.clone())),
-                None => Ok(SteelVal::ListV(l.clone())),
+                Some(_) => Ok(SteelVal::ListV(l)),
+                None => Ok(SteelVal::ListV(l)),
             }
         }
 
         SteelVal::Pair(p) => Ok(p.cdr()),
         _ => {
-            stop!(TypeMismatch => format!("cdr expects a list, found: {}", &args[0]))
+            stop!(TypeMismatch => format!("cdr expects a list, found: {}", &arg))
         }
     }
 }
@@ -766,7 +763,7 @@ mod list_operation_tests {
     #[test]
     fn cdr_normal_input_2_elements() {
         let mut args = [crate::list![1i32, 2i32]];
-        let res = cdr(&mut args);
+        let res = steel_cdr(&mut args);
         let expected = crate::list![2i32];
         assert_eq!(res.unwrap(), expected);
     }
@@ -774,7 +771,7 @@ mod list_operation_tests {
     #[test]
     fn cdr_normal_input_3_elements() {
         let mut args = [crate::list![1i32, 2i32, 3i32]];
-        let res = cdr(&mut args);
+        let res = steel_cdr(&mut args);
         let expected = crate::list![2i32, 3i32];
         assert_eq!(res.unwrap(), expected);
     }
@@ -782,7 +779,7 @@ mod list_operation_tests {
     #[test]
     fn cdr_bad_input() {
         let mut args = [SteelVal::IntV(1)];
-        let res = cdr(&mut args);
+        let res = steel_cdr(&mut args);
         let expected = ErrorKind::TypeMismatch;
         assert_eq!(res.unwrap_err().kind(), expected);
     }
@@ -790,7 +787,7 @@ mod list_operation_tests {
     #[test]
     fn cdr_too_many_args() {
         let mut args = [SteelVal::NumV(1.0), SteelVal::NumV(2.0)];
-        let res = cdr(&mut args);
+        let res = steel_cdr(&mut args);
         let expected = ErrorKind::ArityMismatch;
         assert_eq!(res.unwrap_err().kind(), expected);
     }
@@ -798,7 +795,7 @@ mod list_operation_tests {
     #[test]
     fn cdr_single_element_list() {
         let mut args = [SteelVal::ListV(vec![SteelVal::NumV(1.0)].into())];
-        let res = cdr(&mut args);
+        let res = steel_cdr(&mut args);
         let expected = SteelVal::ListV(List::new());
         assert_eq!(res.unwrap(), expected);
     }
diff --git a/crates/steel-core/src/primitives/nums.rs b/crates/steel-core/src/primitives/nums.rs
index 712c43ef4..8071ee6d0 100644
--- a/crates/steel-core/src/primitives/nums.rs
+++ b/crates/steel-core/src/primitives/nums.rs
@@ -183,10 +183,8 @@ pub fn subtract_primitive(args: &[SteelVal]) -> Result<SteelVal> {
     }
 }
 
-#[steel_derive::native(name = "+", constant = true, arity = "AtLeast(0)")]
-pub fn add_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    ensure_args_are_numbers("+", args)?;
-    let add = |x: &SteelVal, y: &SteelVal| match (x, y) {
+pub fn add_two(x: &SteelVal, y: &SteelVal) -> Result<SteelVal> {
+    match (x, y) {
         // Simple integer case. Probably very common.
         (SteelVal::IntV(x), SteelVal::IntV(y)) => match x.checked_add(y) {
             Some(res) => res.into_steelval(),
@@ -262,15 +260,20 @@ pub fn add_primitive(args: &[SteelVal]) -> Result<SteelVal> {
             res.into_steelval()
         }
         _ => unreachable!(),
-    };
+    }
+}
+
+#[steel_derive::native(name = "+", constant = true, arity = "AtLeast(0)")]
+pub fn add_primitive(args: &[SteelVal]) -> Result<SteelVal> {
+    ensure_args_are_numbers("+", args)?;
     match args {
         [] => 0.into_steelval(),
         [x] => x.clone().into_steelval(),
-        [x, y] => add(x, y),
+        [x, y] => add_two(x, y),
         [x, y, zs @ ..] => {
-            let mut res = add(x, y)?;
+            let mut res = add_two(x, y)?;
             for z in zs {
-                res = add(&res, z)?;
+                res = add_two(&res, z)?;
             }
             res.into_steelval()
         }
diff --git a/crates/steel-core/src/steel_vm/transducers.rs b/crates/steel-core/src/steel_vm/transducers.rs
index c70710f1c..9b9a3fc3b 100644
--- a/crates/steel-core/src/steel_vm/transducers.rs
+++ b/crates/steel-core/src/steel_vm/transducers.rs
@@ -214,8 +214,7 @@ impl<'global, 'a> VmCore<'a> {
                 cur_inst_span,
             ))),
             SteelVal::StringV(s) => Ok(Box::new(s.chars().map(|x| Ok(SteelVal::CharV(x))))),
-            SteelVal::ListV(l) => Ok(Box::new(l.into_iter().cloned().map(Ok))),
-            // SteelVal::StructV(s) => Ok(Box::new(s.iter().cloned().map(Ok))),
+            SteelVal::ListV(l) => Ok(Box::new(l.clone().into_iter().map(Ok))),
             SteelVal::HashSetV(hs) => Ok(Box::new(hs.iter().cloned().map(Ok))),
             SteelVal::HashMapV(hm) => {
                 Ok(Box::new(hm.iter().map(|x| {
@@ -247,22 +246,40 @@ impl<'global, 'a> VmCore<'a> {
 
         let mut iter = Self::res_iterator(&root, Rc::clone(&vm), cur_inst_span, &mut nursery)?;
 
+        // TODO: Almost assuredly, this will not work with continuations, since we won't be
+        // able to capture the rust stack. The best thing to do is probably to "reconstruct"
+        // or pause the closures along the way, so that we could resume this step inside the
+        // continuation at a later time if necessary.
         for t in ops {
             iter = match t {
                 Transducers::Map(stack_func) => {
                     let vm_copy = Rc::clone(&vm);
 
-                    // TODO: Probably should just capture a continuation here?
-                    let switch_statement = move |arg| {
-                        vm_copy.borrow_mut().call_func_or_else(
-                            stack_func,
-                            arg?,
-                            cur_inst_span,
-                            throw!(TypeMismatch => "map expected a function"; *cur_inst_span),
-                        )
-                    };
-
-                    Box::new(iter.map(switch_statement))
+                    // Inlining the switch on the function here saves a decent chunk
+                    // of time since we don't have to dispatch on the function each time.
+                    // Note: This optimization should also be copied to each of the below
+                    // statements, but before that happens I want to figure out
+                    // how to make this all work with continuations.
+                    match stack_func {
+                        SteelVal::FuncV(func) => Box::new(iter.map(move |arg| {
+                            let arg_vec = [arg?];
+                            func(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
+                        })),
+                        SteelVal::BoxedFunction(func) => Box::new(iter.map(move |arg| {
+                            let arg_vec = [arg?];
+                            func.func()(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
+                        })),
+                        SteelVal::MutFunc(func) => Box::new(iter.map(move |arg| {
+                            let mut arg_vec = [arg?];
+                            func(&mut arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
+                        })),
+                        SteelVal::Closure(closure) => {
+                            Box::new(iter.map(move |arg| {
+                                vm_copy.borrow_mut().call_with_one_arg(closure, arg?)
+                            }))
+                        }
+                        _ => stop!(TypeMismatch => "map expected a function"; *cur_inst_span),
+                    }
                 }
                 Transducers::Filter(stack_func) => {
                     let vm_copy = Rc::clone(&vm);
diff --git a/crates/steel-core/src/steel_vm/vm.rs b/crates/steel-core/src/steel_vm/vm.rs
index a9e9d062f..0ee9763b2 100644
--- a/crates/steel-core/src/steel_vm/vm.rs
+++ b/crates/steel-core/src/steel_vm/vm.rs
@@ -1,9 +1,18 @@
 #![allow(unused)]
 
 use crate::core::instructions::pretty_print_dense_instructions;
+use crate::primitives::lists::car;
+use crate::primitives::lists::cdr;
 use crate::primitives::lists::cons;
+use crate::primitives::lists::is_empty;
 use crate::primitives::lists::new as new_list;
 use crate::primitives::lists::steel_car;
+use crate::primitives::lists::steel_cdr;
+use crate::primitives::nums::add_two;
+// use crate::primitives::lists::unsafe_cons;
+use crate::rvals::number_equality;
+use crate::rvals::steel_number_equality;
+use crate::steel_vm::primitives::steel_not;
 use crate::steel_vm::primitives::steel_set_box;
 use crate::steel_vm::primitives::steel_set_box_mutable;
 use crate::steel_vm::primitives::steel_unbox;
@@ -149,6 +158,9 @@ pub struct StackFrame {
     pub(crate) function: crate::gc::unsafe_roots::MaybeRooted<ByteCodeLambda>,
 
     ip: usize,
+
+    // TODO: This should just be... *const [DenseInstruction]
+    // Since Rc<DenseInstruction> should always just be alive?
     instructions: Rc<[DenseInstruction]>,
 
     // TODO: Delete this one!
@@ -771,6 +783,7 @@ impl ContinuationMark {
 }
 
 impl Continuation {
+    #[inline(always)]
     pub fn close_marks(ctx: &VmCore<'_>, stack_frame: &StackFrame) -> bool {
         if let Some(cont_mark) = stack_frame
             .weak_continuation_mark
@@ -1409,18 +1422,10 @@ impl<'a> VmCore<'a> {
                 let arg_vec = [arg];
                 func.func()(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
             }
-            // SteelVal::ContractedFunction(cf) => {
-            //     let arg_vec = vec![arg];
-            //     cf.apply(arg_vec, cur_inst_span, self)
-            // }
             SteelVal::MutFunc(func) => {
-                let mut arg_vec: Vec<_> = vec![arg];
+                let mut arg_vec = [arg];
                 func(&mut arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
             }
-            // SteelVal::BuiltIn(func) => {
-            //     let arg_vec = [arg];
-            //     func(self, &arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            // }
             SteelVal::Closure(closure) => self.call_with_one_arg(closure, arg),
             _ => Err(err()),
         }
@@ -1570,27 +1575,24 @@ impl<'a> VmCore<'a> {
         closure: &Gc<ByteCodeLambda>,
         arg: SteelVal,
     ) -> Result<SteelVal> {
+        thread_local! {
+            static EMPTY_INSTRUCTIONS: Rc<[DenseInstruction]> = Rc::new([]);
+        }
+
         let prev_length = self.thread.stack.len();
 
         self.thread.stack_frames.push(StackFrame::new(
             prev_length,
             Gc::clone(closure),
             0,
-            Rc::from([]),
-            // Rc::from([]),
+            EMPTY_INSTRUCTIONS.with(|x| x.clone()),
         ));
 
         self.sp = prev_length;
 
-        // println!("PUSHING NEW STACK INDEX ON");
-
-        // self.stack_index.push(prev_length);
         self.thread.stack.push(arg);
-        // self.function_stack
-        //     .push(CallContext::new(Gc::clone(closure)));
 
         self.adjust_stack_for_multi_arity(closure, 1, &mut 0)?;
-
         self.call_with_instructions_and_reset_state(closure.body_exp())
     }
 
@@ -1748,51 +1750,30 @@ impl<'a> VmCore<'a> {
             let instr = self.instructions[self.ip];
 
             match instr {
-                DenseInstruction {
-                    op_code: OpCode::DynSuperInstruction,
-                    payload_size,
-                    ..
-                } => {
-                    self.cut_sequence();
-
-                    // TODO: Store in a different spot? So that we can avoid cloning on every iteration?
-                    let super_instruction =
-                        { self.thread.super_instructions[payload_size as usize].clone() };
+                // DenseInstruction {
+                //     op_code: OpCode::DynSuperInstruction,
+                //     payload_size,
+                //     ..
+                // } => {
+                //     self.cut_sequence();
 
-                    super_instruction.call(self)?;
-                }
+                //     // TODO: Store in a different spot? So that we can avoid cloning on every iteration?
+                //     let super_instruction =
+                //         { self.thread.super_instructions[payload_size as usize].clone() };
 
+                //     super_instruction.call(self)?;
+                // }
                 DenseInstruction {
                     op_code: OpCode::POPN,
                     payload_size,
                     ..
                 } => {
                     let last = self.thread.stack.pop().unwrap();
-
-                    // println!("-- POP N: {} -- ", payload_size);
-
-                    // println!("popping: {}", payload_size);
-                    // println!("Stack length: {:?}", self.thread.stack.len());
-
-                    // println!("{:#?}", self.thread.stack);
-
-                    // if payload_size as usize > self.thread.stack.len() {
-                    //     self.thread.stack.clear()
-                    // } else {
-                    //     self.thread
-                    //         .stack
-                    //         .truncate(self.thread.stack.len() - payload_size as usize);
-                    // }
-
                     self.thread
                         .stack
                         .truncate(self.thread.stack.len() - payload_size as usize);
-
                     self.thread.stack.push(last);
-
                     self.ip += 1;
-
-                    // todo!()
                 }
 
                 DenseInstruction {
@@ -1807,8 +1788,6 @@ impl<'a> VmCore<'a> {
                     op_code: OpCode::POPPURE,
                     ..
                 } => {
-                    // println!("-- POP PURE --");
-
                     if let Some(r) = self.handle_pop_pure() {
                         return r;
                     }
@@ -1881,6 +1860,20 @@ impl<'a> VmCore<'a> {
                     car_handler(self)?;
                 }
 
+                DenseInstruction {
+                    op_code: OpCode::NOT,
+                    ..
+                } => {
+                    not_handler(self)?;
+                }
+
+                DenseInstruction {
+                    op_code: OpCode::CDR,
+                    ..
+                } => {
+                    cdr_handler(self)?;
+                }
+
                 DenseInstruction {
                     op_code: OpCode::ADDREGISTER,
                     ..
@@ -1917,22 +1910,25 @@ impl<'a> VmCore<'a> {
                     // get the local
                     // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
                     let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
+                    let l = &self.thread.stack[read_local.payload_size as usize + offset];
 
                     // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
+                    let r = push_const.payload_size as isize;
 
                     // sub_handler_none_int
 
-                    let result = sub_handler_none_int(self, local_value, const_val)?;
+                    // TODO: Inline this here - so that we can just refer to the value
+                    // and don't have to invoke a clone here.
+                    // let result = sub_handler_none_int(self, local_value, const_val)?;
 
-                    // let result = match $name(&[local_value, const_val]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    // };
-
-                    // let result
+                    let result = match l {
+                        SteelVal::IntV(l) => SteelVal::IntV(l - r),
+                        SteelVal::NumV(l) => SteelVal::NumV(l - r as f64),
+                        _ => {
+                            cold();
+                            stop!(TypeMismatch => "sub expected a number, found: {}", l)
+                        }
+                    };
 
                     self.thread.stack.push(result);
 
@@ -1950,23 +1946,21 @@ impl<'a> VmCore<'a> {
                     // get the local
                     // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
                     let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
+                    let l = &self.thread.stack[read_local.payload_size as usize + offset];
 
                     // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
+                    let r = push_const.payload_size as isize;
 
                     // sub_handler_none_int
 
                     // TODO: Probably elide the stack push if the next inst is an IF
-                    let result = lte_handler_none_int(self, local_value, const_val)?;
+                    // let result = lte_handler_none_int(self, local_value, const_val)?;
 
-                    // let result = match $name(&[local_value, const_val]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    // };
-
-                    // let result
+                    let result = match l {
+                        SteelVal::IntV(l) => *l <= r,
+                        SteelVal::NumV(l) => *l <= r as f64,
+                        _ => stop!(TypeMismatch => "lte expected an number, found: {}", r),
+                    };
 
                     self.thread.stack.push(SteelVal::BoolV(result));
 
@@ -1984,16 +1978,21 @@ impl<'a> VmCore<'a> {
                     // get the local
                     // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
                     let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
+                    let l = &self.thread.stack[read_local.payload_size as usize + offset];
 
                     // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
+                    let r = push_const.payload_size as isize;
 
                     // sub_handler_none_int
 
                     // TODO: Probably elide the stack push if the next inst is an IF
-                    let result = lte_handler_none_int(self, local_value, const_val)?;
+                    // let result = lte_handler_none_int(self, local_value, const_val)?;
+
+                    let result = match l {
+                        SteelVal::IntV(l) => *l <= r,
+                        SteelVal::NumV(l) => *l <= r as f64,
+                        _ => stop!(TypeMismatch => "lte expected an number, found: {}", r),
+                    };
 
                     // let result = match $name(&[local_value, const_val]) {
                     //     Ok(value) => value,
@@ -2026,8 +2025,6 @@ impl<'a> VmCore<'a> {
                 } => {
                     // add_handler_payload(self, 2)?;
 
-                    let last_index = self.thread.stack.len() - 2;
-
                     let right = self.thread.stack.pop().unwrap();
                     let left = self.thread.stack.last().unwrap();
 
@@ -2036,23 +2033,9 @@ impl<'a> VmCore<'a> {
                         Err(e) => return Err(e.set_span_if_none(self.current_span())),
                     };
 
-                    // let result = match $name(&mut $ctx.thread.stack[last_index..]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
-                    // };
-
-                    // This is the old way... lets see if the below way improves the speed
-                    // $ctx.thread.stack.truncate(last_index);
-                    // $ctx.thread.stack.push(result);
-
-                    // self.thread.stack.truncate(last_index + 1);
-                    // *self.thread.stack.last_mut().unwrap() = result;
-
                     *self.thread.stack.last_mut().unwrap() = result;
 
                     self.ip += 2;
-
-                    // inline_primitive!(add_primitive, payload_size)
                 }
                 DenseInstruction {
                     op_code: OpCode::SUB,
@@ -2083,6 +2066,24 @@ impl<'a> VmCore<'a> {
                     inline_primitive!(equality_primitive, payload_size);
                 }
 
+                DenseInstruction {
+                    op_code: OpCode::NUMEQUAL,
+                    ..
+                } => {
+                    number_equality_handler(self)?;
+                }
+
+                DenseInstruction {
+                    op_code: OpCode::NULL,
+                    ..
+                } => {
+                    // Simply fast path case for checking null or empty
+                    let last = self.thread.stack.last_mut().unwrap();
+                    let result = is_empty(last);
+                    *last = SteelVal::BoolV(result);
+                    self.ip += 2;
+                }
+
                 DenseInstruction {
                     op_code: OpCode::LTE,
                     payload_size,
@@ -2192,22 +2193,6 @@ impl<'a> VmCore<'a> {
                     self.ip += 1;
                 }
 
-                // DenseInstruction {
-                //     op_code: OpCode::MOVEREADLOCALCALLGLOBAL,
-                //     payload_size,
-                //     ..
-                // } => {
-                //     self.handle_move_local(payload_size as usize)?;
-
-                //     // Move to the next iteration of the loop
-                //     let next_inst = self.instructions[self.ip];
-                //     self.ip += 1;
-                //     let next_next_inst = self.instructions[self.ip];
-                //     self.handle_call_global(
-                //         next_inst.payload_size as usize,
-                //         next_next_inst.payload_size as usize,
-                //     )?;
-                // }
                 DenseInstruction {
                     op_code: OpCode::SETLOCAL,
                     payload_size,
@@ -2267,7 +2252,6 @@ impl<'a> VmCore<'a> {
                     self.ip += 1;
                     let next_inst = self.instructions[self.ip];
                     self.handle_call_global(
-                        // next_inst.payload_size as usize,
                         payload_size as usize,
                         next_inst.payload_size as usize,
                     )?;
@@ -2277,17 +2261,10 @@ impl<'a> VmCore<'a> {
                     payload_size,
                     ..
                 } => {
-                    // println!("calling global tail");
-                    // crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
                     let next_inst = self.instructions[self.ip + 1];
-                    // dbg!(payload_size);
-                    // dbg!(next_inst.payload_size);
-                    // println!("Calling global tail");
                     self.handle_tail_call_global(
-                        // next_inst.payload_size as usize,
                         payload_size as usize,
                         next_inst.payload_size as usize,
-                        // next_inst.payload_size as usize,
                     )?;
                 }
                 DenseInstruction {
@@ -2297,9 +2274,6 @@ impl<'a> VmCore<'a> {
                 } => {
                     // TODO: @Matt -> don't pop the function off of the stack, just read it from there directly.
                     let func = self.thread.stack.pop().unwrap();
-                    // println!("Calling: {}", func);
-                    // pretty_print_dense_instructions(&self.instructions);
-                    // println!("ip: {}", self.ip);
                     self.handle_function_call(func, payload_size as usize)?;
                 }
                 // Tail call basically says "hey this function is exiting"
@@ -2399,17 +2373,7 @@ impl<'a> VmCore<'a> {
                     op_code: OpCode::BEGINSCOPE,
                     ..
                 } => {
-                    // todo!()
                     self.ip += 1;
-                    // self.stack_index.push(self.stack.len());
-                }
-                DenseInstruction {
-                    op_code: OpCode::LetVar,
-                    ..
-                } => {
-                    // todo!()
-                    self.ip += 1;
-                    // self.stack_index.push(self.stack.len());
                 }
                 DenseInstruction {
                     op_code: OpCode::SETALLOC,
@@ -2424,32 +2388,17 @@ impl<'a> VmCore<'a> {
                     op_code: OpCode::ALLOC,
                     ..
                 } => alloc_handler(self)?,
-                // todo!("Implement patching in vars from the stack to the heap");
                 DenseInstruction {
                     op_code: OpCode::LETENDSCOPE,
                     ..
                 } => {
                     let_end_scope_handler(self)?;
                 }
-                // DenseInstruction {
-                //     op_code: OpCode::POP,
-                //     payload_size,
-                //     ..
-                // } => {
-                //     if let Some(r) = self.handle_pop(payload_size) {
-                //         return r;
-                //     }
-                // }
                 DenseInstruction {
                     op_code: OpCode::BIND,
                     payload_size,
                     ..
                 } => self.handle_bind(payload_size as usize),
-                // DenseInstruction {
-                //     op_code: OpCode::SCLOSURE,
-                //     payload_size,
-                //     ..
-                // } => self.handle_start_closure(payload_size as usize),
                 DenseInstruction {
                     op_code: OpCode::NEWSCLOSURE,
                     payload_size,
@@ -2474,7 +2423,6 @@ impl<'a> VmCore<'a> {
                     op_code: OpCode::Arity,
                     ..
                 } => {
-                    // println!("HITTING THIS - THIS SHOULDNT HAPPEN");
                     self.ip += 1;
                 }
                 DenseInstruction {
@@ -2485,7 +2433,6 @@ impl<'a> VmCore<'a> {
                     op_code: OpCode::PASS,
                     ..
                 } => {
-                    // log::warn!("Hitting a pass - this shouldn't happen");
                     self.ip += 1;
                 }
 
@@ -2595,13 +2542,13 @@ impl<'a> VmCore<'a> {
         }
     }
 
+    #[inline(always)]
     fn close_continuation_marks(&self, last: &StackFrame) -> bool {
         // TODO: @Matt - continuation marks should actually do something here
         // What we'd like: This marks the stack frame going out of scope. Since it is going out of scope,
         // the stack frame should check if there are marks here, specifying that we should grab
         // the values out of the existing frame, and "close" the open continuation. That way the continuation (if called)
         // does not need to actually copy the entire frame eagerly, but rather can do so lazily.
-
         Continuation::close_marks(self, last)
     }
 
@@ -2612,70 +2559,28 @@ impl<'a> VmCore<'a> {
 
         self.pop_count -= 1;
 
-        // unwrap just because we want to see if we have something here
-        // rolling back the function stack
-        // self.function_stack.pop();
-
         let last = self.thread.stack_frames.pop();
 
         // let should_return = self.stack_frames.is_empty();
         let should_continue = self.pop_count != 0;
 
         if should_continue {
-            // #[cfg(feature = "unsafe-internals")]
-            // let last = unsafe { last.unwrap_unchecked() };
-
-            // #[cfg(not(feature = "unsafe-internals"))]
             let last = last.unwrap();
 
-            // Update the current frame to be the last one
-            //
-            // self.current_frame = last.clone();
-
-            // let ret_val = self.stack.pop().unwrap();
-
             let rollback_index = last.sp;
 
-            // let ret_val = self.thread.stack.pop().unwrap();
-
-            // for _ in rollback_index..self.thread.stack.len() {
-            //     self.thread.stack.pop();
-            // }
-
-            // self.thread.stack.push(ret_val);
-
-            if self.close_continuation_marks(&last) {
-                // println!("Closed continuation mark");
-                // dbg!(&self.thread.stack);
-            }
-
-            // dbg!(self.thread.stack_frames.len());
-
-            // dbg!(rollback_index);
-            // dbg!(self.thread.stack.len());
-            // last.continuation_mark.map(|x| println!("{:p}", x.inner));
+            self.close_continuation_marks(&last);
 
             let _ = self
                 .thread
                 .stack
                 .drain(rollback_index..self.thread.stack.len() - 1);
 
-            // for value in values {
-            //     dbg!(value);
-            // }
-
-            // self.update_state_with_frame(last);
-            // self.close_continuation_marks(&last);
-
             self.ip = last.ip;
             self.instructions = last.instructions;
 
             self.sp = self.get_last_stack_frame_sp();
 
-            // self.sp = last.index;
-
-            // self.sp = rollback_index;
-
             None
         } else {
             let ret_val = self.thread.stack.pop().ok_or_else(|| {
@@ -2683,13 +2588,12 @@ impl<'a> VmCore<'a> {
                     .with_span(self.current_span())
             });
 
-            last.as_ref().map(|x| {
-                if self.close_continuation_marks(x) {
-                    println!("%%%%%% closed frame %%%%%")
-                }
-            });
-
-            let rollback_index = last.map(|x| x.sp).unwrap_or(0);
+            let rollback_index = last
+                .map(|x| {
+                    self.close_continuation_marks(&x);
+                    x.sp
+                })
+                .unwrap_or(0);
 
             // Move forward past the pop
             self.ip += 1;
@@ -2719,7 +2623,11 @@ impl<'a> VmCore<'a> {
         stop!(Generic => error_message.to_string(); span);
     }
 
-    // #[inline(always)]
+    // TODO: One neat thing to do here would be to
+    // put a guard to move the value out of the top level before
+    // the expression for the set, in an effort to try to
+    // get in place mutation.
+    // Basically a `MoveReadGlobal`
     fn handle_set(&mut self, index: usize) -> Result<()> {
         let value_to_assign = self.thread.stack.pop().unwrap();
 
@@ -3294,14 +3202,13 @@ impl<'a> VmCore<'a> {
     fn handle_tail_call(&mut self, stack_func: SteelVal, payload_size: usize) -> Result<()> {
         use SteelVal::*;
         match stack_func {
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
             FuncV(f) => self.call_primitive_func(f, payload_size),
             MutFunc(f) => self.call_primitive_mut_func(f, payload_size),
-            // ContractedFunction(cf) => self.call_contracted_function_tail_call(&cf, payload_size),
-            ContinuationFunction(cc) => self.call_continuation(cc),
+            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
             Closure(closure) => self.new_handle_tail_call_closure(closure, payload_size),
             BuiltIn(f) => self.call_builtin_func(f, payload_size),
             CustomStruct(s) => self.call_custom_struct(&s, payload_size),
+            ContinuationFunction(cc) => self.call_continuation(cc),
             _ => {
                 // println!("{:?}", self.stack);
                 // println!("{:?}", self.stack_index);
@@ -3469,7 +3376,7 @@ impl<'a> VmCore<'a> {
         }
     }
 
-    // #[inline(always)]
+    #[inline(always)]
     fn call_primitive_func(
         &mut self,
         f: fn(&[SteelVal]) -> Result<SteelVal>,
@@ -4189,21 +4096,13 @@ impl<'a> VmCore<'a> {
         use SteelVal::*;
 
         match stack_func {
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
             FuncV(f) => self.call_primitive_func(f, payload_size),
-            FutureFunc(f) => self.call_future_func(f, payload_size),
             MutFunc(f) => self.call_primitive_mut_func(f, payload_size),
-            // ContractedFunction(cf) => self.call_contracted_function(&cf, payload_size),
-            ContinuationFunction(cc) => self.call_continuation(cc),
             Closure(closure) => self.handle_function_call_closure(closure, payload_size),
-            // #[cfg(feature = "jit")]
-            // CompiledFunction(function) => self.call_compiled_function(function, payload_size)?,
-            // Contract(c) => self.call_contract(&c, payload_size),
-            BuiltIn(f) => {
-                // println!("Calling builtin function, non tail call");
-                // self.ip += 1;
-                self.call_builtin_func(f, payload_size)
-            }
+            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
+            FutureFunc(f) => self.call_future_func(f, payload_size),
+            ContinuationFunction(cc) => self.call_continuation(cc),
+            BuiltIn(f) => self.call_builtin_func(f, payload_size),
             CustomStruct(s) => self.call_custom_struct(&s, payload_size),
             _ => {
                 log::error!("{stack_func:?}");
@@ -5787,6 +5686,52 @@ macro_rules! handler_inline_primitive_payload {
     }};
 }
 
+macro_rules! handler_inline_primitive_payload_1 {
+    ($ctx:expr, $name:tt) => {{
+        let last_index = $ctx.thread.stack.len() - 1;
+
+        let result = match $name(&mut $ctx.thread.stack[last_index..]) {
+            Ok(value) => value,
+            Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
+        };
+
+        *$ctx.thread.stack.last_mut().unwrap() = result;
+
+        $ctx.ip += 2;
+    }};
+}
+
+macro_rules! handler_inline_primitive_payload_1_single {
+    ($ctx:expr, $name:tt) => {{
+        let last = $ctx.thread.stack.last_mut().unwrap();
+
+        let result = match $name(last) {
+            Ok(value) => value,
+            Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
+        };
+
+        *last = result;
+
+        $ctx.ip += 2;
+    }};
+}
+
+macro_rules! handler_inline_primitive_payload_2 {
+    ($ctx:expr, $name:tt) => {{
+        let mut last = $ctx.thread.stack.pop().unwrap();
+        let mut second_last = $ctx.thread.stack.last_mut().unwrap();
+
+        let result = match $name(second_last, &mut last) {
+            Ok(value) => value,
+            Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
+        };
+
+        *second_last = result;
+
+        $ctx.ip += 2;
+    }};
+}
+
 // OpCode::ADD
 fn add_handler(ctx: &mut VmCore<'_>) -> Result<()> {
     handler_inline_primitive!(ctx, add_primitive);
@@ -5866,7 +5811,22 @@ fn setbox_handler(ctx: &mut VmCore<'_>) -> Result<()> {
 }
 
 fn car_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, steel_car, 1);
+    handler_inline_primitive_payload_1_single!(ctx, car);
+    Ok(())
+}
+
+fn not_handler(ctx: &mut VmCore<'_>) -> Result<()> {
+    handler_inline_primitive_payload_1!(ctx, steel_not);
+    Ok(())
+}
+
+fn cdr_handler(ctx: &mut VmCore<'_>) -> Result<()> {
+    handler_inline_primitive_payload_1_single!(ctx, cdr);
+    Ok(())
+}
+
+fn number_equality_handler(ctx: &mut VmCore<'_>) -> Result<()> {
+    handler_inline_primitive_payload_2!(ctx, number_equality);
     Ok(())
 }
 
@@ -6379,34 +6339,7 @@ fn lte_handler_none_int(_: &mut VmCore<'_>, l: SteelVal, r: isize) -> Result<boo
 
 #[inline(always)]
 fn add_handler_none_none(l: &SteelVal, r: &SteelVal) -> Result<SteelVal> {
-    match (l, r) {
-        (SteelVal::IntV(l), SteelVal::IntV(r)) => {
-            if let Some(res) = l.checked_add(*r) {
-                Ok(SteelVal::IntV(res))
-            } else {
-                let mut big = num::BigInt::default();
-
-                big += *l;
-                big += *r;
-
-                big.into_steelval()
-            }
-        }
-        (SteelVal::IntV(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(*l as f64 + r)),
-        (SteelVal::NumV(l), SteelVal::IntV(r)) => Ok(SteelVal::NumV(l + *r as f64)),
-        (SteelVal::NumV(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(l + r)),
-
-        (SteelVal::BigNum(l), SteelVal::BigNum(r)) => (l.as_ref() + r.as_ref()).into_steelval(),
-
-        (SteelVal::IntV(l), SteelVal::BigNum(r)) => (r.as_ref() + *l).into_steelval(),
-
-        (SteelVal::BigNum(l), SteelVal::IntV(r)) => (l.as_ref() + *r).into_steelval(),
-
-        (SteelVal::NumV(l), SteelVal::BigNum(r)) => Ok(SteelVal::NumV(r.to_f64().unwrap() + *l)),
-        (SteelVal::BigNum(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(l.to_f64().unwrap() + *r)),
-
-        _ => stop!(TypeMismatch => "+ expected two numbers, found: {} and {}", l, r),
-    }
+    add_two(l, r)
 }
 
 #[cfg(feature = "dynamic")]
diff --git a/crates/steel-core/src/values/lists.rs b/crates/steel-core/src/values/lists.rs
index b52adef6e..8b56ff90b 100644
--- a/crates/steel-core/src/values/lists.rs
+++ b/crates/steel-core/src/values/lists.rs
@@ -55,24 +55,18 @@ mod list_drop_handler {
 
     use crate::rvals::cycles::{drop_impls::DROP_BUFFER, IterativeDropHandler};
 
-    impl
-        DropHandler<
-            im_lists::list::GenericList<SteelVal, im_lists::shared::RcPointer, 256, 1, Self>,
-        > for ListDropHandler
+    impl DropHandler<im_lists::list::GenericList<SteelVal, im_lists::shared::RcPointer, 4, 2, Self>>
+        for ListDropHandler
     {
         fn drop_handler(
             obj: &mut im_lists::list::GenericList<
                 SteelVal,
                 im_lists::shared::RcPointer,
-                256,
-                1,
+                4,
+                2,
                 Self,
             >,
         ) {
-            // println!("CALLING DROP HANDLER: {}", obj.strong_count());
-            // DEPTH.with(|x| x.set(x.get() + 1));
-            // println!("Current depth: {}", DEPTH.with(|x| x.get()));
-
             if obj.strong_count() == 1 {
                 if obj.is_empty() {
                     return;
@@ -81,16 +75,55 @@ mod list_drop_handler {
                 if DROP_BUFFER
                     .try_with(|drop_buffer| {
                         if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
+                            // Optimistically check what these values are. If they're
+                            // primitives, then we can just skip pushing them back
+                            // entirely.
                             for value in std::mem::take(obj).draining_iterator() {
-                                drop_buffer.push_back(value);
+                                match &value {
+                                    SteelVal::BoolV(_)
+                                    | SteelVal::NumV(_)
+                                    | SteelVal::IntV(_)
+                                    | SteelVal::CharV(_)
+                                    | SteelVal::Void
+                                    | SteelVal::StringV(_)
+                                    | SteelVal::FuncV(_)
+                                    | SteelVal::SymbolV(_)
+                                    | SteelVal::FutureFunc(_)
+                                    | SteelVal::FutureV(_)
+                                    | SteelVal::BoxedFunction(_)
+                                    | SteelVal::MutFunc(_)
+                                    | SteelVal::BuiltIn(_)
+                                    | SteelVal::BigNum(_) => continue,
+                                    _ => {
+                                        drop_buffer.push_back(value);
+                                    }
+                                }
                             }
 
                             IterativeDropHandler::bfs(&mut drop_buffer);
                         } else {
                             let mut drop_buffer = VecDeque::new();
 
-                            for value in std::mem::take(obj) {
-                                drop_buffer.push_back(value);
+                            for value in std::mem::take(obj).draining_iterator() {
+                                match &value {
+                                    SteelVal::BoolV(_)
+                                    | SteelVal::NumV(_)
+                                    | SteelVal::IntV(_)
+                                    | SteelVal::CharV(_)
+                                    | SteelVal::Void
+                                    | SteelVal::StringV(_)
+                                    | SteelVal::FuncV(_)
+                                    | SteelVal::SymbolV(_)
+                                    | SteelVal::FutureFunc(_)
+                                    | SteelVal::FutureV(_)
+                                    | SteelVal::BoxedFunction(_)
+                                    | SteelVal::MutFunc(_)
+                                    | SteelVal::BuiltIn(_)
+                                    | SteelVal::BigNum(_) => continue,
+                                    _ => {
+                                        drop_buffer.push_back(value);
+                                    }
+                                }
                             }
 
                             IterativeDropHandler::bfs(&mut drop_buffer);
@@ -100,7 +133,25 @@ mod list_drop_handler {
                 {
                     let mut drop_buffer = VecDeque::new();
                     for value in std::mem::take(obj).draining_iterator() {
-                        drop_buffer.push_back(value);
+                        match &value {
+                            SteelVal::BoolV(_)
+                            | SteelVal::NumV(_)
+                            | SteelVal::IntV(_)
+                            | SteelVal::CharV(_)
+                            | SteelVal::Void
+                            | SteelVal::StringV(_)
+                            | SteelVal::FuncV(_)
+                            | SteelVal::SymbolV(_)
+                            | SteelVal::FutureFunc(_)
+                            | SteelVal::FutureV(_)
+                            | SteelVal::BoxedFunction(_)
+                            | SteelVal::MutFunc(_)
+                            | SteelVal::BuiltIn(_)
+                            | SteelVal::BigNum(_) => continue,
+                            _ => {
+                                drop_buffer.push_back(value);
+                            }
+                        }
                     }
 
                     IterativeDropHandler::bfs(&mut drop_buffer);
@@ -113,17 +164,17 @@ mod list_drop_handler {
 }
 
 pub type SteelList<T> =
-    im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, DefaultDropHandler>;
+    im_lists::list::GenericList<T, im_lists::shared::RcPointer, 4, 2, DefaultDropHandler>;
 
 // TODO: Change this to just be something like `SteelList`
 pub type List<T> =
-    im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, DropHandlerChoice>;
+    im_lists::list::GenericList<T, im_lists::shared::RcPointer, 4, 2, DropHandlerChoice>;
 
 pub type ConsumingIterator<T> =
-    im_lists::list::ConsumingIter<T, im_lists::shared::RcPointer, 256, 1, DropHandlerChoice>;
+    im_lists::list::ConsumingIter<T, im_lists::shared::RcPointer, 4, 2, DropHandlerChoice>;
 
 impl<T: FromSteelVal + Clone, D: im_lists::handler::DropHandler<Self>> FromSteelVal
-    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, D>
+    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 4, 2, D>
 {
     fn from_steelval(val: &SteelVal) -> crate::rvals::Result<Self> {
         if let SteelVal::ListV(l) = val {
@@ -135,7 +186,7 @@ impl<T: FromSteelVal + Clone, D: im_lists::handler::DropHandler<Self>> FromSteel
 }
 
 impl<T: IntoSteelVal + Clone, D: im_lists::handler::DropHandler<Self>> IntoSteelVal
-    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, D>
+    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 4, 2, D>
 {
     fn into_steelval(self) -> crate::rvals::Result<SteelVal> {
         self.into_iter()
diff --git a/crates/steel-gen/src/opcode.rs b/crates/steel-gen/src/opcode.rs
index 3062aa053..e5fef103e 100644
--- a/crates/steel-gen/src/opcode.rs
+++ b/crates/steel-gen/src/opcode.rs
@@ -88,11 +88,13 @@ declare_opcodes! {
         MUL;
         DIV;
         EQUAL;
+        NUMEQUAL;
+        NULL;
         LTE;
         CONS; // Cons should be... probably specialized
         LIST;
         CAR;
-        // CDR;
+        CDR;
         NEWBOX;
         SETBOX;
         UNBOX;
@@ -111,7 +113,9 @@ declare_opcodes! {
         SUBIMMEDIATE;
         LTEIMMEDIATE;
         BINOPADD;
-        LTEIMMEDIATEIF
+        BINOPSUB;
+        LTEIMMEDIATEIF;
+        NOT
     }
 
     // Super instructions
diff --git a/r7rs-benchmarks/nqueens.scm b/r7rs-benchmarks/nqueens.scm
new file mode 100644
index 000000000..5c81a22d3
--- /dev/null
+++ b/r7rs-benchmarks/nqueens.scm
@@ -0,0 +1,40 @@
+(provide nqueens)
+
+(define trace? #f)
+
+(define (ok? row dist placed)
+  (if (null? placed)
+      #t
+      (and (not (= (car placed) (+ row dist)))
+           (not (= (car placed) (- row dist)))
+           (ok? row (+ dist 1) (cdr placed)))))
+
+(define (nqueens n)
+
+  (define (iota1 n)
+    (let loop ([i n] [l '()])
+      (if (= i 0) l (loop (- i 1) (cons i l)))))
+
+  (define (my-try x y z)
+    (if (null? x)
+        (if (null? y)
+            (begin
+              (when trace?
+                (begin
+                  (write z)
+                  (newline)))
+              1)
+            0)
+        (+ (if (ok? (car x) 1 z) (my-try (append (cdr x) y) '() (cons (car x) z)) 0)
+           (my-try (cdr x) (cons (car x) y) z))))
+
+  ; (define (ok? row dist placed)
+  ;   (if (null? placed)
+  ;       #t
+  ;       (and (not (= (car placed) (+ row dist)))
+  ;            (not (= (car placed) (- row dist)))
+  ;            (ok? row (+ dist 1) (cdr placed)))))
+
+  (my-try (iota1 n) '() '()))
+
+; (nqueens 13)