diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs
index e97c015d09..7044a8f6a8 100644
--- a/compiler/build/src/program.rs
+++ b/compiler/build/src/program.rs
@@ -95,7 +95,7 @@ pub fn gen_from_mono_module(
         }
 
         if name.starts_with("roc_builtins.dict") || name.starts_with("dict.RocDict") {
-            function.add_attribute(AttributeLoc::Function, attr);
+            // function.add_attribute(AttributeLoc::Function, attr);
         }
     }
 
diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs
index 0f27af068c..59844ef74e 100644
--- a/compiler/can/src/builtins.rs
+++ b/compiler/can/src/builtins.rs
@@ -1980,46 +1980,12 @@ fn list_map(symbol: Symbol, var_store: &mut VarStore) -> Def {
 
 /// Dict.hashTestOnly : k, v -> Nat
 pub fn dict_hash_test_only(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let key_var = var_store.fresh();
-    let value_var = var_store.fresh();
-    let nat_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::Hash,
-        args: vec![
-            (key_var, Var(Symbol::ARG_1)),
-            (value_var, Var(Symbol::ARG_2)),
-        ],
-        ret_var: nat_var,
-    };
-
-    defn(
-        symbol,
-        vec![(key_var, Symbol::ARG_1), (value_var, Symbol::ARG_2)],
-        var_store,
-        body,
-        nat_var,
-    )
+    lowlevel_2(symbol, LowLevel::Hash, var_store)
 }
 
 /// Dict.len : Dict * * -> Nat
 fn dict_len(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let size_var = var_store.fresh();
-    let dict_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictSize,
-        args: vec![(dict_var, Var(Symbol::ARG_1))],
-        ret_var: size_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1)],
-        var_store,
-        body,
-        size_var,
-    )
+    lowlevel_1(symbol, LowLevel::DictSize, var_store)
 }
 
 /// Dict.empty : Dict * *
@@ -2073,78 +2039,17 @@ fn dict_singleton(symbol: Symbol, var_store: &mut VarStore) -> Def {
 
 /// Dict.insert : Dict k v, k, v -> Dict k v
 fn dict_insert(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let key_var = var_store.fresh();
-    let val_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictInsert,
-        args: vec![
-            (dict_var, Var(Symbol::ARG_1)),
-            (key_var, Var(Symbol::ARG_2)),
-            (val_var, Var(Symbol::ARG_3)),
-        ],
-        ret_var: dict_var,
-    };
-
-    defn(
-        symbol,
-        vec![
-            (dict_var, Symbol::ARG_1),
-            (key_var, Symbol::ARG_2),
-            (val_var, Symbol::ARG_3),
-        ],
-        var_store,
-        body,
-        dict_var,
-    )
+    lowlevel_3(symbol, LowLevel::DictInsert, var_store)
 }
 
 /// Dict.remove : Dict k v, k -> Dict k v
 fn dict_remove(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let key_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictRemove,
-        args: vec![
-            (dict_var, Var(Symbol::ARG_1)),
-            (key_var, Var(Symbol::ARG_2)),
-        ],
-        ret_var: dict_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1), (key_var, Symbol::ARG_2)],
-        var_store,
-        body,
-        dict_var,
-    )
+    lowlevel_2(symbol, LowLevel::DictRemove, var_store)
 }
 
 /// Dict.contains : Dict k v, k -> Bool
 fn dict_contains(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let key_var = var_store.fresh();
-    let bool_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictContains,
-        args: vec![
-            (dict_var, Var(Symbol::ARG_1)),
-            (key_var, Var(Symbol::ARG_2)),
-        ],
-        ret_var: bool_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1), (key_var, Symbol::ARG_2)],
-        var_store,
-        body,
-        bool_var,
-    )
+    lowlevel_2(symbol, LowLevel::DictContains, var_store)
 }
 
 /// Dict.get : Dict k v, k -> Result v [ KeyNotFound ]*
@@ -2230,108 +2135,32 @@ fn dict_get(symbol: Symbol, var_store: &mut VarStore) -> Def {
 
 /// Dict.keys : Dict k v -> List k
 fn dict_keys(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let list_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictKeys,
-        args: vec![(dict_var, Var(Symbol::ARG_1))],
-        ret_var: list_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1)],
-        var_store,
-        body,
-        list_var,
-    )
+    lowlevel_1(symbol, LowLevel::DictKeys, var_store)
 }
 
 /// Dict.values : Dict k v -> List v
 fn dict_values(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let list_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictValues,
-        args: vec![(dict_var, Var(Symbol::ARG_1))],
-        ret_var: list_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1)],
-        var_store,
-        body,
-        list_var,
-    )
-}
-
-///  Dict k v, Dict k v -> Dict k v
-fn dict_dict_dict(symbol: Symbol, op: LowLevel, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op,
-        args: vec![
-            (dict_var, Var(Symbol::ARG_1)),
-            (dict_var, Var(Symbol::ARG_2)),
-        ],
-        ret_var: dict_var,
-    };
-
-    defn(
-        symbol,
-        vec![(dict_var, Symbol::ARG_1), (dict_var, Symbol::ARG_2)],
-        var_store,
-        body,
-        dict_var,
-    )
+    lowlevel_1(symbol, LowLevel::DictValues, var_store)
 }
 
 /// Dict.union : Dict k v, Dict k v -> Dict k v
 fn dict_union(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    dict_dict_dict(symbol, LowLevel::DictUnion, var_store)
+    lowlevel_2(symbol, LowLevel::DictUnion, var_store)
 }
 
 /// Dict.difference : Dict k v, Dict k v -> Dict k v
 fn dict_difference(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    dict_dict_dict(symbol, LowLevel::DictDifference, var_store)
+    lowlevel_2(symbol, LowLevel::DictDifference, var_store)
 }
 
 /// Dict.intersection : Dict k v, Dict k v -> Dict k v
 fn dict_intersection(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    dict_dict_dict(symbol, LowLevel::DictIntersection, var_store)
+    lowlevel_2(symbol, LowLevel::DictIntersection, var_store)
 }
 
 /// Dict.walk : Dict k v, (k, v, accum -> accum), accum -> accum
 fn dict_walk(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let dict_var = var_store.fresh();
-    let func_var = var_store.fresh();
-    let accum_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictWalk,
-        args: vec![
-            (dict_var, Var(Symbol::ARG_1)),
-            (func_var, Var(Symbol::ARG_2)),
-            (accum_var, Var(Symbol::ARG_3)),
-        ],
-        ret_var: accum_var,
-    };
-
-    defn(
-        symbol,
-        vec![
-            (dict_var, Symbol::ARG_1),
-            (func_var, Symbol::ARG_2),
-            (accum_var, Symbol::ARG_3),
-        ],
-        var_store,
-        body,
-        accum_var,
-    )
+    lowlevel_3(symbol, LowLevel::DictWalk, var_store)
 }
 
 /// Set.empty : Set *
@@ -2385,42 +2214,22 @@ fn set_singleton(symbol: Symbol, var_store: &mut VarStore) -> Def {
 
 /// Set.len : Set * -> Nat
 fn set_len(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    let size_var = var_store.fresh();
-    let set_var = var_store.fresh();
-
-    let body = RunLowLevel {
-        op: LowLevel::DictSize,
-        args: vec![(set_var, Var(Symbol::ARG_1))],
-        ret_var: size_var,
-    };
-
-    defn(
-        symbol,
-        vec![(set_var, Symbol::ARG_1)],
-        var_store,
-        body,
-        size_var,
-    )
-}
-
-///  Set k, Set k -> Set k
-fn set_set_set(symbol: Symbol, op: LowLevel, var_store: &mut VarStore) -> Def {
-    dict_dict_dict(symbol, op, var_store)
+    lowlevel_1(symbol, LowLevel::DictSize, var_store)
 }
 
 /// Dict.union : Dict k v, Dict k v -> Dict k v
 fn set_union(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    set_set_set(symbol, LowLevel::DictUnion, var_store)
+    lowlevel_2(symbol, LowLevel::DictUnion, var_store)
 }
 
 /// Dict.difference : Dict k v, Dict k v -> Dict k v
 fn set_difference(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    set_set_set(symbol, LowLevel::DictDifference, var_store)
+    lowlevel_2(symbol, LowLevel::DictDifference, var_store)
 }
 
 /// Dict.intersection : Dict k v, Dict k v -> Dict k v
 fn set_intersection(symbol: Symbol, var_store: &mut VarStore) -> Def {
-    set_set_set(symbol, LowLevel::DictIntersection, var_store)
+    lowlevel_2(symbol, LowLevel::DictIntersection, var_store)
 }
 
 /// Set.toList : Set k -> List k
diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs
index c7d806ef85..20cb197c55 100644
--- a/compiler/gen/src/llvm/build.rs
+++ b/compiler/gen/src/llvm/build.rs
@@ -2245,29 +2245,11 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>(
                     let (value, layout) = load_symbol_and_layout(scope, symbol);
 
                     if layout.is_refcounted() {
-                        match value {
-                            BasicValueEnum::PointerValue(value_ptr) => {
-                                let refcount_ptr =
-                                    PointerToRefcount::from_ptr_to_data(env, value_ptr);
-                                refcount_ptr.decrement(env, layout);
-                            }
-                            BasicValueEnum::StructValue(_value_struct) => {
-                                match layout {
-                                    Layout::Builtin(Builtin::Str)
-                                    | Layout::Builtin(Builtin::List(_, _))
-                                    | Layout::Builtin(Builtin::Dict(_, _))
-                                    | Layout::Builtin(Builtin::Set(_)) => {
-                                        // let refcount_ptr = PointerToRefcount::from_list_wrapper(env, value_struct);
-                                        // refcount_ptr.decrement(env, layout);
-                                        eprintln!("we are likely leaking some memory, see #985 for details");
-                                    }
-                                    _ => unreachable!(
-                                        "decref on weird type, likely a closure? {:?}",
-                                        layout
-                                    ),
-                                }
-                            }
-                            _ => unreachable!("cannot be decref'd"),
+                        if value.is_pointer_value() {
+                            // BasicValueEnum::PointerValue(value_ptr) => {
+                            let value_ptr = value.into_pointer_value();
+                            let refcount_ptr = PointerToRefcount::from_ptr_to_data(env, value_ptr);
+                            refcount_ptr.decrement(env, layout);
                         }
                     }