diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs
index f848d2ce36..5aaefa463b 100644
--- a/compiler/load/src/file.rs
+++ b/compiler/load/src/file.rs
@@ -2113,8 +2113,6 @@ fn update<'a>(
                     &mut state.procedures,
                 );
 
-                Proc::insert_refcount_operations(arena, &mut state.procedures);
-
                 // display the mono IR of the module, for debug purposes
                 if roc_mono::ir::PRETTY_PRINT_IR_SYMBOLS {
                     let procs_string = state
@@ -2128,6 +2126,8 @@ fn update<'a>(
                     println!("{}", result);
                 }
 
+                Proc::insert_refcount_operations(arena, &mut state.procedures);
+
                 // This is not safe with the new non-recursive RC updates that we do for tag unions
                 //
                 //                Proc::optimize_refcount_operations(
diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs
index b14afb4682..5d1a679a12 100644
--- a/compiler/mono/src/layout.rs
+++ b/compiler/mono/src/layout.rs
@@ -618,7 +618,9 @@ impl<'a> LambdaSet<'a> {
         use UnionVariant::*;
         match variant {
             Never => Layout::Union(UnionLayout::NonRecursive(&[])),
-            Unit | UnitWithArguments | BoolUnion { .. } | ByteUnion(_) => {
+            BoolUnion { .. } => Layout::Builtin(Builtin::Int1),
+            ByteUnion { .. } => Layout::Builtin(Builtin::Int8),
+            Unit | UnitWithArguments => {
                 // no useful information to store
                 Layout::Struct(&[])
             }
diff --git a/compiler/test_mono/generated/somehow_drops_definitions.txt b/compiler/test_mono/generated/somehow_drops_definitions.txt
index 15ddbd26c6..2e7a497919 100644
--- a/compiler/test_mono/generated/somehow_drops_definitions.txt
+++ b/compiler/test_mono/generated/somehow_drops_definitions.txt
@@ -1,43 +1,53 @@
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Test.24 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Test.24;
+    let Test.27 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Test.27;
 
 procedure Num.26 (#Attr.2, #Attr.3):
-    let Test.19 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Test.19;
-
-procedure Test.1 ():
-    let Test.25 = 1i64;
-    ret Test.25;
-
-procedure Test.2 ():
-    let Test.20 = 2i64;
-    ret Test.20;
-
-procedure Test.3 (Test.6):
-    let Test.23 = CallByName Test.1;
-    let Test.22 = CallByName Num.24 Test.6 Test.23;
+    let Test.22 = lowlevel NumMul #Attr.2 #Attr.3;
     ret Test.22;
 
+procedure Test.1 ():
+    let Test.28 = 1i64;
+    ret Test.28;
+
+procedure Test.2 ():
+    let Test.23 = 2i64;
+    ret Test.23;
+
+procedure Test.3 (Test.6):
+    let Test.26 = CallByName Test.1;
+    let Test.25 = CallByName Num.24 Test.6 Test.26;
+    ret Test.25;
+
 procedure Test.4 (Test.7):
-    let Test.18 = CallByName Test.2;
-    let Test.17 = CallByName Num.26 Test.7 Test.18;
-    ret Test.17;
+    let Test.21 = CallByName Test.2;
+    let Test.20 = CallByName Num.26 Test.7 Test.21;
+    ret Test.20;
 
 procedure Test.5 (Test.8, Test.9):
-    let Test.14 = CallByName Test.3 Test.9;
-    ret Test.14;
+    joinpoint Test.15 Test.14:
+        ret Test.14;
+    in
+    switch Test.8:
+        case 0:
+            let Test.16 = CallByName Test.3 Test.9;
+            jump Test.15 Test.16;
+    
+        default:
+            let Test.17 = CallByName Test.4 Test.9;
+            jump Test.15 Test.17;
+    
 
 procedure Test.0 ():
-    joinpoint Test.16 Test.12:
+    joinpoint Test.19 Test.12:
         let Test.13 = 42i64;
         let Test.11 = CallByName Test.5 Test.12 Test.13;
         ret Test.11;
     in
-    let Test.21 = true;
-    if Test.21 then
-        let Test.3 = Struct {};
-        jump Test.16 Test.3;
+    let Test.24 = true;
+    if Test.24 then
+        let Test.3 = false;
+        jump Test.19 Test.3;
     else
-        let Test.4 = Struct {};
-        jump Test.16 Test.4;
+        let Test.4 = true;
+        jump Test.19 Test.4;