diff --git a/crates/aiken-lang/src/gen_uplc/decision_tree.rs b/crates/aiken-lang/src/gen_uplc/decision_tree.rs
index e0ad7adf..7be67f44 100644
--- a/crates/aiken-lang/src/gen_uplc/decision_tree.rs
+++ b/crates/aiken-lang/src/gen_uplc/decision_tree.rs
@@ -1532,4 +1532,46 @@ mod tester {
 
         println!("{}", tree);
     }
+
+    #[test]
+    fn thing6() {
+        let source_code = r#"
+            test thing(){
+                when [] is {
+                  [] -> 4 == 4
+                  [a, 1, ..c] -> True
+                  [a, b, c, d, 5, ..f] -> False
+                  _ -> 1 == 1
+                }
+            }
+        "#;
+
+        let (_, ast) = check(parse(source_code)).unwrap();
+
+        let Definition::Test(function) = &ast.definitions[0] else {
+            panic!()
+        };
+
+        let TypedExpr::When {
+            clauses, subject, ..
+        } = &function.body
+        else {
+            panic!()
+        };
+
+        let mut air_interner = AirInterner::new();
+
+        let data_types = IndexMap::new();
+
+        let pattern = TypedPattern::Discard {
+            name: "_".to_string(),
+            location: Span::empty(),
+        };
+
+        let tree_gen = TreeGen::new(&mut air_interner, &data_types, &pattern);
+
+        let tree = tree_gen.build_tree(&subject.tipo(), clauses);
+
+        println!("{}", tree);
+    }
 }
diff --git a/crates/aiken-project/src/tests/gen_uplc.rs b/crates/aiken-project/src/tests/gen_uplc.rs
index ca40db9d..16e81cad 100644
--- a/crates/aiken-project/src/tests/gen_uplc.rs
+++ b/crates/aiken-project/src/tests/gen_uplc.rs
@@ -3087,30 +3087,75 @@ fn acceptance_test_29_union_pair() {
 
     "#;
 
-    let do_insert = Term::var("elems")
-        .delayed_choose_list(
-            Term::mk_cons()
-                .apply(
-                    Term::mk_pair_data()
-                        .apply(Term::b_data().apply(Term::var("k")))
-                        .apply(Term::i_data().apply(Term::var("v"))),
-                )
-                .apply(Term::empty_map()),
-            Term::head_list()
-                .apply(Term::var("elems"))
-                .as_var("elem_0", |elem_0| {
-                    Term::tail_list()
-                        .apply(Term::var("elems"))
-                        .as_var("rest", |rest| {
-                            Term::un_b_data()
-                                .apply(Term::fst_pair().apply(Term::Var(elem_0.clone())))
-                                .as_var("k2", |k2| {
-                                    Term::un_i_data()
-                                        .apply(Term::snd_pair().apply(Term::Var(elem_0.clone())))
-                                        .as_var("v2", |v2| {
+    let uplc =
+        Term::equals_data()
+            .apply(
+                Term::map_data().apply(
+                    Term::var("union")
+                        .lambda("union")
+                        .apply(
+                            Term::var("do_union")
+                                .apply(Term::var("left"))
+                                .apply(Term::var("right"))
+                                .lambda("right")
+                                .lambda("left"),
+                        )
+                        .lambda("do_union")
+                        .apply(Term::var("do_union").apply(Term::var("do_union")))
+                        .lambda("do_union")
+                        .apply(
+                            Term::var("left")
+                                .delayed_choose_list(
+                                    Term::var("right"),
+                                    Term::var("do_union")
+                                        .apply(Term::var("do_union"))
+                                        .apply(Term::var("rest"))
+                                        .apply(
+                                            Term::var("do_insert")
+                                                .apply(Term::var("right"))
+                                                .apply(Term::var("k"))
+                                                .apply(Term::var("v")),
+                                        )
+                                        .lambda("rest")
+                                        .lambda("v")
+                                        .lambda("k")
+                                        .apply(
+                                            Term::un_b_data()
+                                                .apply(Term::fst_pair().apply(Term::var("tuple"))),
+                                        )
+                                        .apply(
+                                            Term::un_i_data()
+                                                .apply(Term::snd_pair().apply(Term::var("tuple"))),
+                                        )
+                                        .apply(Term::tail_list().apply(Term::var("left")))
+                                        .lambda("tuple")
+                                        .apply(Term::head_list().apply(Term::var("left"))),
+                                )
+                                .lambda("right")
+                                .lambda("left")
+                                .lambda("do_union"),
+                        )
+                        .lambda("do_insert")
+                        .apply(
+                            Term::var("do_insert")
+                                .apply(Term::var("do_insert"))
+                                .apply(Term::var("elems"))
+                                .lambda("do_insert")
+                                .apply(
+                                    Term::var("elems")
+                                        .delayed_choose_list(
+                                            Term::mk_cons()
+                                                .apply(
+                                                    Term::mk_pair_data()
+                                                        .apply(Term::b_data().apply(Term::var("k")))
+                                                        .apply(
+                                                            Term::i_data().apply(Term::var("v")),
+                                                        ),
+                                                )
+                                                .apply(Term::empty_map()),
                                             Term::equals_bytestring()
                                                 .apply(Term::var("k"))
-                                                .apply(Term::Var(k2.clone()))
+                                                .apply(Term::var("k2"))
                                                 .delayed_if_then_else(
                                                     Term::mk_cons()
                                                         .apply(
@@ -3124,126 +3169,72 @@ fn acceptance_test_29_union_pair() {
                                                                         .apply(Term::var("v")),
                                                                 ),
                                                         )
-                                                        .apply(Term::Var(rest.clone())),
+                                                        .apply(Term::var("rest")),
                                                     Term::mk_cons()
                                                         .apply(
                                                             Term::mk_pair_data()
                                                                 .apply(
                                                                     Term::b_data()
-                                                                        .apply(Term::Var(k2)),
+                                                                        .apply(Term::var("k2")),
                                                                 )
                                                                 .apply(
                                                                     Term::i_data()
-                                                                        .apply(Term::Var(v2)),
+                                                                        .apply(Term::var("v2")),
                                                                 ),
                                                         )
                                                         .apply(
                                                             Term::var("do_insert")
                                                                 .apply(Term::var("do_insert"))
-                                                                .apply(Term::Var(rest)),
+                                                                .apply(Term::var("rest")),
                                                         ),
                                                 )
-                                        })
-                                })
-                        })
-                }),
-        )
-        .lambda("elems")
-        .lambda("do_insert");
-
-    let do_insert_recurse = do_insert
-        .as_var("do_insert", |do_insert| {
-            Term::Var(do_insert.clone())
-                .apply(Term::Var(do_insert))
-                .apply(Term::var("elems"))
-        })
-        .lambda("v")
-        .lambda("k")
-        .lambda("elems");
-
-    let insert = Term::var("do_insert")
-        .apply(Term::var("m"))
-        .apply(Term::var("k"))
-        .apply(Term::var("v"))
-        .lambda("v")
-        .lambda("k")
-        .lambda("m");
-
-    let empty_list = Term::empty_map();
-
-    let fixture = Term::data(Data::map(vec![
-        (
-            Data::bytestring(vec![0x66, 0x6f, 0x6f]),
-            Data::integer(42.into()),
-        ),
-        (
-            Data::bytestring(vec![0x62, 0x61, 0x72]),
-            Data::integer(14.into()),
-        ),
-    ]));
-
-    let fixture_unwrapped = Term::Constant(
-        Constant::ProtoList(
-            Type::Pair(Type::Data.into(), Type::Data.into()),
-            vec![
-                Constant::ProtoPair(
-                    Type::Data,
-                    Type::Data,
-                    Constant::Data(Data::bytestring(vec![0x66, 0x6f, 0x6f])).into(),
-                    Constant::Data(Data::integer(42.into())).into(),
-                ),
-                Constant::ProtoPair(
-                    Type::Data,
-                    Type::Data,
-                    Constant::Data(Data::bytestring(vec![0x62, 0x61, 0x72])).into(),
-                    Constant::Data(Data::integer(14.into())).into(),
-                ),
-            ],
-        )
-        .into(),
-    );
-
-    let do_union = Term::var("left")
-        .delayed_choose_list(
-            Term::var("right"),
-            Term::head_list()
-                .apply(Term::var("left"))
-                .as_var("elem_0", |elem_0| {
-                    Term::var("do_union")
-                        .apply(Term::var("do_union"))
-                        .apply(Term::tail_list().apply(Term::var("left")))
-                        .apply(
-                            Term::var("do_insert")
-                                .apply(Term::var("right"))
-                                .apply(
-                                    Term::un_b_data()
-                                        .apply(Term::fst_pair().apply(Term::Var(elem_0.clone()))),
+                                                .lambda("rest")
+                                                .lambda("v2")
+                                                .lambda("k2")
+                                                .apply(Term::un_b_data().apply(
+                                                    Term::fst_pair().apply(Term::var("tuple")),
+                                                ))
+                                                .apply(Term::un_i_data().apply(
+                                                    Term::snd_pair().apply(Term::var("tuple")),
+                                                ))
+                                                .apply(Term::tail_list().apply(Term::var("elems")))
+                                                .lambda("tuple")
+                                                .apply(Term::head_list().apply(Term::var("elems"))),
+                                        )
+                                        .lambda("elems")
+                                        .lambda("do_insert"),
                                 )
-                                .apply(
-                                    Term::un_i_data()
-                                        .apply(Term::snd_pair().apply(Term::Var(elem_0))),
-                                ),
+                                .lambda("v")
+                                .lambda("k")
+                                .lambda("elems"),
                         )
-                }),
-        )
-        .lambda("right")
-        .lambda("left")
-        .lambda("do_union");
-
-    let uplc = Term::equals_data()
-        .apply(
-            Term::map_data().apply(do_union.as_var("do_union", |do_union| {
-                Term::Var(do_union.clone())
-                    .apply(Term::Var(do_union))
-                    .apply(fixture_unwrapped)
-                    .apply(empty_list)
-            })),
-        )
-        .apply(fixture)
-        .lambda("insert")
-        .apply(insert)
-        .lambda("do_insert")
-        .apply(do_insert_recurse);
+                        .apply(Term::map_values(vec![
+                            Constant::ProtoPair(
+                                Type::Data,
+                                Type::Data,
+                                Constant::Data(Data::bytestring(vec![0x66, 0x6f, 0x6f])).into(),
+                                Constant::Data(Data::integer(42.into())).into(),
+                            ),
+                            Constant::ProtoPair(
+                                Type::Data,
+                                Type::Data,
+                                Constant::Data(Data::bytestring(vec![0x62, 0x61, 0x72])).into(),
+                                Constant::Data(Data::integer(14.into())).into(),
+                            ),
+                        ]))
+                        .apply(Term::empty_map()),
+                ),
+            )
+            .apply(Term::data(Data::map(vec![
+                (
+                    Data::bytestring(vec![0x66, 0x6f, 0x6f]),
+                    Data::integer(42.into()),
+                ),
+                (
+                    Data::bytestring(vec![0x62, 0x61, 0x72]),
+                    Data::integer(14.into()),
+                ),
+            ])));
 
     assert_uplc(src, uplc.clone(), false, true);
     assert_uplc(src, uplc, false, false);