Improve rewriter speed

Andres and I met today, and discovered that there's a source of
non-linear complexity in the rewriter which is not type casts.

In adding side-conditions to the rewrite rules (which are not discussed
in the pattern-matching compilation paper), I represented them by
allowing rewrite rules to fail.  So, for example,

    # + x ~~> x (when # == 0)

is represented as

    # + x ~~> if (# =? 0) then Some x else None

In the case that a rewrite rule fails, we need to try all other rewrite
rules that might still apply.  However, doing this in the naive-CPS way
leads to non-linear blowup, because wildcard rewrite rules get
duplicated in the failure branches.  (This is similar to the issue that
`match x with "some string" => true | _ => false end%string` will
generate a large number of "false" branches, and duplicate "false"
across all of them, rather than having a single default case.)
For example, if we had the rewrite rules

    # + # ~~> literal sum
    x + (-y) ~~> x - y
    (-x) + y ~~> y - x

then the compiled code would look like
    fun x y
      => if x is a literal
         then if y is a literal
              then literal sum
              else if y is an opp
                   then x - y
                   else x + y
         else if y is an opp
         then x - y
         else if x is an opp
              then y - x
              else x + y

where we actually want the code

    fun x y
      => if x is a literal
         then if y is a literal
              then return (literal sum);
         if y is an opp
         then return (x - y);
         if x is an opp
         then return (y - x);
         return (x + y)

in the sequence+return monad.  i.e., we want to not duplicate the "if y
is an opp" code multiple times.

I think the solution to this is to have the discrimination tree
evaluator return an option, and to have the function that computes the
discrimination tree not duplicate rewrite rules among different cases.

Note that this leads to slightly inefficient matching sometimes: when
two rules with the same structure are separated by a rule with a
wildcard instead of structure, we will now try to match on the structure
twice.  It might be useful to be able to denote that some rewrite rules
can be commuted.

After     | File Name                                                            | Before    || Change     | % Change
----------------------------------------------------------------------------------------------------------------------
40m35.83s | Total                                                                | 30m00.99s || +10m34.84s | +35.24%
----------------------------------------------------------------------------------------------------------------------
21m46.37s | Experiments/NewPipeline/SlowPrimeSynthesisExamples                   | 6m01.39s  || +15m44.97s | +261.48%
6m37.40s  | p384_32.c                                                            | 0m22.47s  || +6m14.92s  | +1668.58%
0m18.00s  | Experiments/NewPipeline/Rewriter                                     | 5m16.50s  || -4m58.50s  | -94.31%
0m30.49s  | Experiments/NewPipeline/ExtractionHaskell/unsaturated_solinas        | 1m54.20s  || -1m23.71s  | -73.30%
0m27.41s  | Experiments/NewPipeline/ExtractionHaskell/saturated_solinas          | 1m39.40s  || -1m11.99s  | -72.42%
0m47.78s  | Experiments/NewPipeline/ExtractionHaskell/word_by_word_montgomery    | 1m54.50s  || -1m06.71s  | -58.27%
0m40.28s  | Experiments/NewPipeline/ExtractionOCaml/word_by_word_montgomery      | 1m23.77s  || -0m43.48s  | -51.91%
0m15.21s  | Experiments/NewPipeline/ExtractionOCaml/saturated_solinas            | 0m55.86s  || -0m40.64s  | -72.77%
0m23.39s  | Experiments/NewPipeline/ExtractionOCaml/unsaturated_solinas          | 1m00.22s  || -0m36.82s  | -61.15%
0m21.85s  | p256_32.c                                                            | 0m04.01s  || +0m17.84s  | +444.88%
0m20.97s  | secp256k1_32.c                                                       | 0m03.26s  || +0m17.71s  | +543.25%
0m04.60s  | Experiments/NewPipeline/ExtractionOCaml/saturated_solinas.ml         | 0m20.33s  || -0m15.72s  | -77.37%
0m09.48s  | Experiments/NewPipeline/ExtractionOCaml/word_by_word_montgomery.ml   | 0m23.28s  || -0m13.80s  | -59.27%
1m33.63s  | Experiments/NewPipeline/Toplevel2                                    | 1m45.56s  || -0m11.93s  | -11.30%
0m08.29s  | Experiments/NewPipeline/ExtractionOCaml/unsaturated_solinas.ml       | 0m18.64s  || -0m10.35s  | -55.52%
0m05.93s  | Experiments/NewPipeline/ExtractionHaskell/word_by_word_montgomery.hs | 0m16.74s  || -0m10.80s  | -64.57%
0m32.41s  | p521_64.c                                                            | 0m41.42s  || -0m09.01s  | -21.75%
0m04.93s  | Experiments/NewPipeline/ExtractionHaskell/unsaturated_solinas.hs     | 0m14.92s  || -0m09.99s  | -66.95%
0m04.40s  | Experiments/NewPipeline/ExtractionHaskell/saturated_solinas.hs       | 0m12.57s  || -0m08.16s  | -64.99%
0m08.52s  | p224_32.c                                                            | 0m01.95s  || +0m06.56s  | +336.92%
0m13.99s  | p384_64.c                                                            | 0m10.64s  || +0m03.34s  | +31.48%
4m07.13s  | Experiments/NewPipeline/Toplevel1                                    | 4m05.83s  || +0m01.29s  | +0.52%
0m38.96s  | p521_32.c                                                            | 0m40.09s  || -0m01.13s  | -2.81%
0m02.28s  | p224_64.c                                                            | 0m01.66s  || +0m00.61s  | +37.34%
0m02.27s  | curve25519_32.c                                                      | 0m01.98s  || +0m00.29s  | +14.64%
0m01.78s  | p256_64.c                                                            | 0m01.65s  || +0m00.13s  | +7.87%
0m01.70s  | secp256k1_64.c                                                       | 0m01.96s  || -0m00.26s  | -13.26%
0m01.65s  | curve25519_64.c                                                      | 0m01.51s  || +0m00.13s  | +9.27%
0m01.37s  | Experiments/NewPipeline/CLI                                          | 0m01.26s  || +0m00.11s  | +8.73%
0m01.15s  | Experiments/NewPipeline/StandaloneHaskellMain                        | 0m01.21s  || -0m00.06s  | -4.95%
0m01.14s  | Experiments/NewPipeline/StandaloneOCamlMain                          | 0m01.16s  || -0m00.02s  | -1.72%
0m01.07s  | Experiments/NewPipeline/CompilersTestCases                           | 0m01.05s  || +0m00.02s  | +1.90%

1 files changed, 4006 insertions, 15697 deletions

diff --git a/src/Experiments/NewPipeline/arith_rewrite_head.out b/src/Experiments/NewPipeline/arith_rewrite_head.out
index 23b5205d2..994eaa810 100644
--- a/src/Experiments/NewPipeline/arith_rewrite_head.out
+++ b/src/Experiments/NewPipeline/arith_rewrite_head.out
@@ -8,39 +8,57 @@ match idc in (ident t) return (Compile.value' true t) with
          UnderLets.UnderLets base.type ident var
            (defaults.expr (type.base t0)))
     with
-    | base.type.unit => fun v0 : unit => UnderLets.Base ##(v0)%expr
-    | base.type.Z => fun v0 : Z => UnderLets.Base ##(v0)%expr
-    | base.type.bool => fun v0 : bool => UnderLets.Base ##(v0)%expr
-    | base.type.nat => fun v0 : nat => UnderLets.Base ##(v0)%expr
+    | base.type.unit =>
+        fun v0 : unit => llet default := UnderLets.Base ##(v0)%expr in
+        default
+    | base.type.Z =>
+        fun v0 : Z => llet default := UnderLets.Base ##(v0)%expr in
+        default
+    | base.type.bool =>
+        fun v0 : bool => llet default := UnderLets.Base ##(v0)%expr in
+        default
+    | base.type.nat =>
+        fun v0 : nat => llet default := UnderLets.Base ##(v0)%expr in
+        default
     end v
 | ident.Nat_succ =>
     fun x : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_succ)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_succ)%expr @ x)%expr_pat in
+    default
 | ident.Nat_pred =>
     fun x : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_pred)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_pred)%expr @ x)%expr_pat in
+    default
 | ident.Nat_max =>
     fun x x0 : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_max)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_max)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Nat_mul =>
     fun x x0 : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_mul)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_mul)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Nat_add =>
     fun x x0 : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_add)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_add)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Nat_sub =>
     fun x x0 : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Nat_sub)%expr @ x @ x0)%expr_pat
-| @ident.nil t => UnderLets.Base []%expr_pat
+    llet default := UnderLets.Base (#(ident.Nat_sub)%expr @ x @ x0)%expr_pat in
+    default
+| @ident.nil t => llet default := UnderLets.Base []%expr_pat in
+    default
 | @ident.cons t =>
     fun (x : defaults.expr (type.base t))
       (x0 : defaults.expr (type.base (base.type.list t))) =>
-    UnderLets.Base (x :: x0)%expr_pat
+    llet default := UnderLets.Base (x :: x0)%expr_pat in
+    default
 | @ident.pair A B =>
     fun (x : defaults.expr (type.base A)) (x0 : defaults.expr (type.base B))
-    => UnderLets.Base (x, x0)%expr_pat
+    => llet default := UnderLets.Base (x, x0)%expr_pat in
+    default
 | @ident.fst A B =>
     fun x : defaults.expr (type.base (A * B)%etype) =>
+    llet default := UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat in
     match x with
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ #(idc)%expr_pat x1) x0 =>
         match
@@ -79,32 +97,30 @@ match idc in (ident t) return (Compile.value' true t) with
                                 defaults.expr (type.base A)) =>
                        match a with
                        | Some x' => UnderLets.Base (x' v)
-                       | None =>
-                           UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+                       | None => default
                        end)
                 | (s1 -> d1)%ptype =>
                     fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    => UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+                    => default
                 end (Compile.reflect x0)
             | (s1 -> d1)%ptype =>
                 fun _ : Compile.value' false s1 -> Compile.value' true d1 =>
-                UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+                default
             end (Compile.reflect x1)
-        | None => UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+        | None => default
         end
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ ($_)%expr _) _ | @expr.App _
       _ _ s _ (@expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _) _ | @expr.App
       _ _ _ s _ (@expr.App _ _ _ s0 _ (_ @ _)%expr_pat _) _ | @expr.App _ _ _
-      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ =>
-        UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ => default
     | @expr.App _ _ _ s _ #(_)%expr_pat _ | @expr.App _ _ _ s _ ($_)%expr _ |
       @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-      (@expr.LetIn _ _ _ _ _ _ _) _ =>
-        UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
-    | _ => UnderLets.Base (#(ident.fst)%expr @ x)%expr_pat
+      (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default
     end
 | @ident.snd A B =>
     fun x : defaults.expr (type.base (A * B)%etype) =>
+    llet default := UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat in
     match x with
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ #(idc)%expr_pat x1) x0 =>
         match
@@ -143,29 +159,26 @@ match idc in (ident t) return (Compile.value' true t) with
                                 defaults.expr (type.base B)) =>
                        match a with
                        | Some x' => UnderLets.Base (x' v0)
-                       | None =>
-                           UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+                       | None => default
                        end)
                 | (s1 -> d1)%ptype =>
                     fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    => UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+                    => default
                 end (Compile.reflect x0)
             | (s1 -> d1)%ptype =>
                 fun _ : Compile.value' false s1 -> Compile.value' true d1 =>
-                UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+                default
             end (Compile.reflect x1)
-        | None => UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+        | None => default
         end
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ ($_)%expr _) _ | @expr.App _
       _ _ s _ (@expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _) _ | @expr.App
       _ _ _ s _ (@expr.App _ _ _ s0 _ (_ @ _)%expr_pat _) _ | @expr.App _ _ _
-      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ =>
-        UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ => default
     | @expr.App _ _ _ s _ #(_)%expr_pat _ | @expr.App _ _ _ s _ ($_)%expr _ |
       @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-      (@expr.LetIn _ _ _ _ _ _ _) _ =>
-        UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
-    | _ => UnderLets.Base (#(ident.snd)%expr @ x)%expr_pat
+      (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default
     end
 | @ident.prod_rect A B T =>
     fun
@@ -174,10 +187,11 @@ match idc in (ident t) return (Compile.value' true t) with
            UnderLets.UnderLets base.type ident var
              (defaults.expr (type.base T)))
       (x0 : defaults.expr (type.base (A * B)%etype)) =>
-    UnderLets.Base
-      (#(ident.prod_rect)%expr @
-       (λ (x1 : var (type.base A))(x2 : var (type.base B)),
-        UnderLets.to_expr (x ($x1) ($x2)))%expr @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.prod_rect)%expr @
+                       (λ (x1 : var (type.base A))(x2 : var (type.base B)),
+                        UnderLets.to_expr (x ($x1) ($x2)))%expr @ x0)%expr_pat in
+    default
 | @ident.bool_rect T =>
     fun
       (x
@@ -185,12 +199,13 @@ match idc in (ident t) return (Compile.value' true t) with
             UnderLets.UnderLets base.type ident var
               (defaults.expr (type.base T)))
       (x1 : defaults.expr (type.base base.type.bool)) =>
-    UnderLets.Base
-      (#(ident.bool_rect)%expr @
-       (λ x2 : var (type.base base.type.unit),
-        UnderLets.to_expr (x ($x2)))%expr @
-       (λ x2 : var (type.base base.type.unit),
-        UnderLets.to_expr (x0 ($x2)))%expr @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.bool_rect)%expr @
+                       (λ x2 : var (type.base base.type.unit),
+                        UnderLets.to_expr (x ($x2)))%expr @
+                       (λ x2 : var (type.base base.type.unit),
+                        UnderLets.to_expr (x0 ($x2)))%expr @ x1)%expr_pat in
+    default
 | @ident.nat_rect P =>
     fun
       (x : defaults.expr (type.base base.type.unit) ->
@@ -201,12 +216,15 @@ match idc in (ident t) return (Compile.value' true t) with
             UnderLets.UnderLets base.type ident var
               (defaults.expr (type.base P)))
       (x1 : defaults.expr (type.base base.type.nat)) =>
-    UnderLets.Base
-      (#(ident.nat_rect)%expr @
-       (λ x2 : var (type.base base.type.unit),
-        UnderLets.to_expr (x ($x2)))%expr @
-       (λ (x2 : var (type.base base.type.nat))(x3 : var (type.base P)),
-        UnderLets.to_expr (x0 ($x2) ($x3)))%expr @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.nat_rect)%expr @
+                       (λ x2 : var (type.base base.type.unit),
+                        UnderLets.to_expr (x ($x2)))%expr @
+                       (λ (x2 : var (type.base base.type.nat))(x3 : var
+                                                                    (type.base
+                                                                    P)),
+                        UnderLets.to_expr (x0 ($x2) ($x3)))%expr @ x1)%expr_pat in
+    default
 | @ident.nat_rect_arrow P Q =>
     fun
       (x : defaults.expr (type.base P) ->
@@ -221,18 +239,22 @@ match idc in (ident t) return (Compile.value' true t) with
               (defaults.expr (type.base Q)))
       (x1 : defaults.expr (type.base base.type.nat))
       (x2 : defaults.expr (type.base P)) =>
-    UnderLets.Base
-      (#(ident.nat_rect_arrow)%expr @
-       (λ x3 : var (type.base P),
-        UnderLets.to_expr (x ($x3)))%expr @
-       (λ (x3 : var (type.base base.type.nat))(x4 : var
-                                                      (type.base P ->
-                                                       type.base Q)%ptype)
-        (x5 : var (type.base P)),
-        UnderLets.to_expr
-          (x0 ($x3)
-             (fun x6 : defaults.expr (type.base P) =>
-              UnderLets.Base ($x4 @ x6)%expr_pat) ($x5)))%expr @ x1 @ x2)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.nat_rect_arrow)%expr @
+                       (λ x3 : var (type.base P),
+                        UnderLets.to_expr (x ($x3)))%expr @
+                       (λ (x3 : var (type.base base.type.nat))(x4 : var
+                                                                    (type.base
+                                                                    P ->
+                                                                    type.base
+                                                                    Q)%ptype)
+                        (x5 : var (type.base P)),
+                        UnderLets.to_expr
+                          (x0 ($x3)
+                             (fun x6 : defaults.expr (type.base P) =>
+                              UnderLets.Base ($x4 @ x6)%expr_pat) ($x5)))%expr @
+                       x1 @ x2)%expr_pat in
+    default
 | @ident.list_rect A P =>
     fun
       (x : defaults.expr (type.base base.type.unit) ->
@@ -244,13 +266,19 @@ match idc in (ident t) return (Compile.value' true t) with
             UnderLets.UnderLets base.type ident var
               (defaults.expr (type.base P)))
       (x1 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base
-      (#(ident.list_rect)%expr @
-       (λ x2 : var (type.base base.type.unit),
-        UnderLets.to_expr (x ($x2)))%expr @
-       (λ (x2 : var (type.base A))(x3 : var (type.base (base.type.list A)))
-        (x4 : var (type.base P)),
-        UnderLets.to_expr (x0 ($x2) ($x3) ($x4)))%expr @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.list_rect)%expr @
+                       (λ x2 : var (type.base base.type.unit),
+                        UnderLets.to_expr (x ($x2)))%expr @
+                       (λ (x2 : var (type.base A))(x3 : var
+                                                          (type.base
+                                                             (base.type.list
+                                                                A)))(x4 : 
+                                                                    var
+                                                                    (type.base
+                                                                    P)),
+                        UnderLets.to_expr (x0 ($x2) ($x3) ($x4)))%expr @ x1)%expr_pat in
+    default
 | @ident.list_case A P =>
     fun
       (x : defaults.expr (type.base base.type.unit) ->
@@ -261,70 +289,89 @@ match idc in (ident t) return (Compile.value' true t) with
             UnderLets.UnderLets base.type ident var
               (defaults.expr (type.base P)))
       (x1 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base
-      (#(ident.list_case)%expr @
-       (λ x2 : var (type.base base.type.unit),
-        UnderLets.to_expr (x ($x2)))%expr @
-       (λ (x2 : var (type.base A))(x3 : var (type.base (base.type.list A))),
-        UnderLets.to_expr (x0 ($x2) ($x3)))%expr @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.list_case)%expr @
+                       (λ x2 : var (type.base base.type.unit),
+                        UnderLets.to_expr (x ($x2)))%expr @
+                       (λ (x2 : var (type.base A))(x3 : var
+                                                          (type.base
+                                                             (base.type.list
+                                                                A))),
+                        UnderLets.to_expr (x0 ($x2) ($x3)))%expr @ x1)%expr_pat in
+    default
 | @ident.List_length T =>
     fun x : defaults.expr (type.base (base.type.list T)) =>
-    UnderLets.Base (#(ident.List_length)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.List_length)%expr @ x)%expr_pat in
+    default
 | ident.List_seq =>
     fun x x0 : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.List_seq)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.List_seq)%expr @ x @ x0)%expr_pat in
+    default
 | @ident.List_firstn A =>
     fun (x : defaults.expr (type.base base.type.nat))
       (x0 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base (#(ident.List_firstn)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_firstn)%expr @ x @ x0)%expr_pat in
+    default
 | @ident.List_skipn A =>
     fun (x : defaults.expr (type.base base.type.nat))
       (x0 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base (#(ident.List_skipn)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_skipn)%expr @ x @ x0)%expr_pat in
+    default
 | @ident.List_repeat A =>
     fun (x : defaults.expr (type.base A))
       (x0 : defaults.expr (type.base base.type.nat)) =>
-    UnderLets.Base (#(ident.List_repeat)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_repeat)%expr @ x @ x0)%expr_pat in
+    default
 | @ident.List_combine A B =>
     fun (x : defaults.expr (type.base (base.type.list A)))
       (x0 : defaults.expr (type.base (base.type.list B))) =>
-    UnderLets.Base (#(ident.List_combine)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_combine)%expr @ x @ x0)%expr_pat in
+    default
 | @ident.List_map A B =>
     fun
       (x : defaults.expr (type.base A) ->
            UnderLets.UnderLets base.type ident var
              (defaults.expr (type.base B)))
       (x0 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base
-      (#(ident.List_map)%expr @
-       (λ x1 : var (type.base A),
-        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_map)%expr @
+                       (λ x1 : var (type.base A),
+                        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat in
+    default
 | @ident.List_app A =>
     fun x x0 : defaults.expr (type.base (base.type.list A)) =>
-    UnderLets.Base (x ++ x0)%expr
+    llet default := UnderLets.Base (x ++ x0)%expr in
+    default
 | @ident.List_rev A =>
     fun x : defaults.expr (type.base (base.type.list A)) =>
-    UnderLets.Base (#(ident.List_rev)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.List_rev)%expr @ x)%expr_pat in
+    default
 | @ident.List_flat_map A B =>
     fun
       (x : defaults.expr (type.base A) ->
            UnderLets.UnderLets base.type ident var
              (defaults.expr (type.base (base.type.list B))))
       (x0 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base
-      (#(ident.List_flat_map)%expr @
-       (λ x1 : var (type.base A),
-        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_flat_map)%expr @
+                       (λ x1 : var (type.base A),
+                        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat in
+    default
 | @ident.List_partition A =>
     fun
       (x : defaults.expr (type.base A) ->
            UnderLets.UnderLets base.type ident var
              (defaults.expr (type.base base.type.bool)))
       (x0 : defaults.expr (type.base (base.type.list A))) =>
-    UnderLets.Base
-      (#(ident.List_partition)%expr @
-       (λ x1 : var (type.base A),
-        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_partition)%expr @
+                       (λ x1 : var (type.base A),
+                        UnderLets.to_expr (x ($x1)))%expr @ x0)%expr_pat in
+    default
 | @ident.List_fold_right A B =>
     fun
       (x : defaults.expr (type.base B) ->
@@ -333,511 +380,413 @@ match idc in (ident t) return (Compile.value' true t) with
              (defaults.expr (type.base A)))
       (x0 : defaults.expr (type.base A))
       (x1 : defaults.expr (type.base (base.type.list B))) =>
-    UnderLets.Base
-      (#(ident.List_fold_right)%expr @
-       (λ (x2 : var (type.base B))(x3 : var (type.base A)),
-        UnderLets.to_expr (x ($x2) ($x3)))%expr @ x0 @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_fold_right)%expr @
+                       (λ (x2 : var (type.base B))(x3 : var (type.base A)),
+                        UnderLets.to_expr (x ($x2) ($x3)))%expr @ x0 @ x1)%expr_pat in
+    default
 | @ident.List_update_nth T =>
     fun (x : defaults.expr (type.base base.type.nat))
       (x0 : defaults.expr (type.base T) ->
             UnderLets.UnderLets base.type ident var
               (defaults.expr (type.base T)))
       (x1 : defaults.expr (type.base (base.type.list T))) =>
-    UnderLets.Base
-      (#(ident.List_update_nth)%expr @ x @
-       (λ x2 : var (type.base T),
-        UnderLets.to_expr (x0 ($x2)))%expr @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_update_nth)%expr @ x @
+                       (λ x2 : var (type.base T),
+                        UnderLets.to_expr (x0 ($x2)))%expr @ x1)%expr_pat in
+    default
 | @ident.List_nth_default T =>
     fun (x : defaults.expr (type.base T))
       (x0 : defaults.expr (type.base (base.type.list T)))
       (x1 : defaults.expr (type.base base.type.nat)) =>
-    UnderLets.Base (#(ident.List_nth_default)%expr @ x @ x0 @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.List_nth_default)%expr @ x @ x0 @ x1)%expr_pat in
+    default
 | ident.Z_add =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    match x with
-    | #(idc)%expr_pat =>
-        match
-          match idc with
-          | @ident.Literal t0 v =>
-              match t0 as t1 return (base.base_interp t1 -> option Z) with
-              | base.type.unit => fun _ : unit => None
-              | base.type.Z => fun v0 : Z => Some v0
-              | base.type.bool => fun _ : bool => None
-              | base.type.nat => fun _ : nat => None
-              end v
-          | _ => None
-          end
-        with
-        | Some args =>
-            if args =? 0
-            then UnderLets.Base x0
-            else
-             match x0 with
-             | #(idc0)%expr_pat =>
-                 match
-                   match idc0 with
-                   | @ident.Literal t1 v =>
-                       match
-                         t1 as t2 return (base.base_interp t2 -> option Z)
-                       with
-                       | base.type.unit => fun _ : unit => None
-                       | base.type.Z => fun v0 : Z => Some v0
-                       | base.type.bool => fun _ : bool => None
-                       | base.type.nat => fun _ : nat => None
-                       end v
-                   | _ => None
-                   end
-                 with
-                 | Some args0 =>
-                     if args0 =? 0
-                     then UnderLets.Base x
-                     else UnderLets.Base (x + x0)%expr
-                 | None => UnderLets.Base (x + x0)%expr
-                 end
-             | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
-                 match
-                   match idc0 with
-                   | ident.Z_opp => Some tt
-                   | _ => None
-                   end
-                 with
-                 | Some _ =>
-                     match
-                       s as t2
-                       return
-                         (Compile.value' false t2 ->
-                          UnderLets.UnderLets base.type ident var
-                            (defaults.expr (type.base base.type.Z)))
-                     with
-                     | type.base t2 =>
-                         fun v : defaults.expr (type.base t2) =>
-                         base.try_make_transport_cps
-                           (fun t1 : base.type =>
-                            defaults.expr (type.base t1)) t2 base.type.Z
-                           (UnderLets.UnderLets base.type ident var
-                              (defaults.expr (type.base base.type.Z)))
-                           (fun
-                              a : option
-                                    (defaults.expr (type.base t2) ->
-                                     defaults.expr (type.base base.type.Z))
-                            =>
-                            match a with
-                            | Some x' =>
-                                if args >? 0
-                                then UnderLets.Base (##(args) - x' v)%expr
-                                else
-                                 match
-                                   s as t3
-                                   return
-                                     (Compile.value' false t3 ->
-                                      UnderLets.UnderLets base.type ident var
-                                        (defaults.expr
-                                           (type.base base.type.Z)))
-                                 with
-                                 | type.base t3 =>
-                                     fun v0 : defaults.expr (type.base t3) =>
-                                     base.try_make_transport_cps
-                                       (fun t1 : base.type =>
-                                        defaults.expr (type.base t1)) t3
-                                       base.type.Z
-                                       (UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base base.type.Z)))
-                                       (fun
-                                          a0 : option
-                                                 (defaults.expr
-                                                    (type.base t3) ->
-                                                  defaults.expr
-                                                    (type.base base.type.Z))
-                                        =>
-                                        match a0 with
-                                        | Some x'0 =>
-                                            if args <? 0
-                                            then
-                                             UnderLets.Base
-                                               (- (##((- args)%Z) + x'0 v0))%expr
-                                            else
-                                             match
-                                               s as t4
-                                               return
-                                                 (Compile.value' false t4 ->
-                                                  UnderLets.UnderLets
-                                                    base.type ident var
-                                                    (defaults.expr
-                                                       (type.base base.type.Z)))
-                                             with
-                                             | type.base t4 =>
-                                                 fun
-                                                   v1 : defaults.expr
-                                                          (type.base t4) =>
-                                                 base.try_make_transport_cps
-                                                   (fun t1 : base.type =>
-                                                    defaults.expr
-                                                      (type.base t1)) t4
-                                                   base.type.Z
-                                                   (UnderLets.UnderLets
-                                                      base.type ident var
-                                                      (defaults.expr
-                                                         (type.base
-                                                            base.type.Z)))
-                                                   (fun
-                                                      a1 : option
+    llet default := UnderLets.Base (x + x0)%expr in
+    llet default0 := fun 'tt =>
+                     llet default0 := fun 'tt =>
+                                      llet default0 := fun 'tt =>
+                                                       match x0 with
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match
+                                                                 s as t2
+                                                                 return
+                                                                   (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                               with
+                                                               | type.base
+                                                                 t2 =>
+                                                                   fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                   base.try_make_transport_cps
+                                                                    (fun
+                                                                    t0 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t0)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    UnderLets.Base
+                                                                    (x - x' v)%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                               | (s0 -> d0)%ptype =>
+                                                                   fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                   => default
+                                                               end
+                                                                 (Compile.reflect
+                                                                    x1)
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default
+                                                       end in
+                                      match x with
+                                      | @expr.App _ _ _ s _ #(idc)%expr_pat
+                                        x1 =>
+                                          match
+                                            match idc with
+                                            | ident.Z_opp => Some tt
+                                            | _ => None
+                                            end
+                                          with
+                                          | Some _ =>
+                                              match
+                                                s as t2
+                                                return
+                                                  (Compile.value' false t2 ->
+                                                   UnderLets.UnderLets
+                                                     base.type ident var
+                                                     (defaults.expr
+                                                        (type.base
+                                                           base.type.Z)))
+                                              with
+                                              | type.base t2 =>
+                                                  fun
+                                                    v : defaults.expr
+                                                          (type.base t2) =>
+                                                  base.try_make_transport_cps
+                                                    (fun t0 : base.type =>
+                                                     defaults.expr
+                                                       (type.base t0)) t2
+                                                    base.type.Z
+                                                    (UnderLets.UnderLets
+                                                       base.type ident var
+                                                       (defaults.expr
+                                                          (type.base
+                                                             base.type.Z)))
+                                                    (fun
+                                                       a : option
                                                              (defaults.expr
-                                                                (type.base t4) ->
+                                                                (type.base t2) ->
                                                               defaults.expr
                                                                 (type.base
                                                                    base.type.Z))
-                                                    =>
-                                                    match a1 with
-                                                    | Some x'1 =>
-                                                        UnderLets.Base
-                                                          (x - x'1 v1)%expr
-                                                    | None =>
-                                                        UnderLets.Base
-                                                          (x + x0)%expr
-                                                    end)
-                                             | (s0 -> d0)%ptype =>
-                                                 fun
-                                                   _ : Compile.value' false
-                                                         s0 ->
-                                                       Compile.value' true d0
-                                                 =>
-                                                 UnderLets.Base (x + x0)%expr
-                                             end (Compile.reflect x1)
-                                        | None =>
-                                            UnderLets.Base (x + x0)%expr
-                                        end)
-                                 | (s0 -> d0)%ptype =>
-                                     fun
-                                       _ : Compile.value' false s0 ->
-                                           Compile.value' true d0 =>
-                                     UnderLets.Base (x + x0)%expr
-                                 end (Compile.reflect x1)
-                            | None => UnderLets.Base (x + x0)%expr
-                            end)
-                     | (s0 -> d0)%ptype =>
-                         fun
-                           _ : Compile.value' false s0 ->
-                               Compile.value' true d0 =>
-                         UnderLets.Base (x + x0)%expr
-                     end (Compile.reflect x1)
-                 | None => UnderLets.Base (x + x0)%expr
-                 end
-             | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-               (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-               (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-               (@expr.LetIn _ _ _ _ _ _ _) _ => UnderLets.Base (x + x0)%expr
-             | _ => UnderLets.Base (x + x0)%expr
-             end
-        | None =>
-            match x0 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args =? 0
-                    then UnderLets.Base x
-                    else UnderLets.Base (x + x0)%expr
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ => UnderLets.Base (x + x0)%expr
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        end
-    | ($_)%expr =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else UnderLets.Base (x + x0)%expr
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v0 : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t1 : base.type => defaults.expr (type.base t1)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x - x' v0)%expr
-                       | None => UnderLets.Base (x + x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x + x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x + x0)%expr
-        | _ => UnderLets.Base (x + x0)%expr
-        end
-    | @expr.Abs _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else UnderLets.Base (x + x0)%expr
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x - x' v)%expr
-                       | None => UnderLets.Base (x + x0)%expr
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    => UnderLets.Base (x + x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _ _ _ s0 _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0 _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x + x0)%expr
-        | _ => UnderLets.Base (x + x0)%expr
-        end
-    | @expr.App _ _ _ s _ f x1 =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else
-                 match f with
-                 | #(idc0)%expr_pat =>
-                     match
-                       match idc0 with
-                       | ident.Z_opp => Some tt
-                       | _ => None
-                       end
-                     with
-                     | Some _ =>
+                                                     =>
+                                                     match a with
+                                                     | Some x' =>
+                                                         UnderLets.Base
+                                                           (x0 - x' v)%expr
+                                                     | None => default
+                                                     end)
+                                              | (s0 -> d0)%ptype =>
+                                                  fun
+                                                    _ : Compile.value' false
+                                                          s0 ->
+                                                        Compile.value' true
+                                                          d0 => default
+                                              end (Compile.reflect x1)
+                                          | None => default
+                                          end
+                                      | @expr.App _ _ _ s _ ($_)%expr _ |
+                                        @expr.App _ _ _ s _
+                                        (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                                        _ _ _ s _ (_ @ _)%expr_pat _ |
+                                        @expr.App _ _ _ s _
+                                        (@expr.LetIn _ _ _ _ _ _ _) _ =>
+                                          default
+                                      | _ => default0 tt
+                                      end in
+                     match x0 with
+                     | #(idc)%expr_pat =>
                          match
-                           s as t2
-                           return
-                             (Compile.value' false t2 ->
-                              UnderLets.UnderLets base.type ident var
-                                (defaults.expr (type.base base.type.Z)))
+                           match idc with
+                           | @ident.Literal t0 v =>
+                               match
+                                 t0 as t1
+                                 return (base.base_interp t1 -> option Z)
+                               with
+                               | base.type.unit => fun _ : unit => None
+                               | base.type.Z => fun v0 : Z => Some v0
+                               | base.type.bool => fun _ : bool => None
+                               | base.type.nat => fun _ : nat => None
+                               end v
+                           | _ => None
+                           end
                          with
-                         | type.base t2 =>
-                             fun v : defaults.expr (type.base t2) =>
-                             base.try_make_transport_cps
-                               (fun t1 : base.type =>
-                                defaults.expr (type.base t1)) t2 base.type.Z
-                               (UnderLets.UnderLets base.type ident var
-                                  (defaults.expr (type.base base.type.Z)))
-                               (fun
-                                  a : option
-                                        (defaults.expr (type.base t2) ->
-                                         defaults.expr
-                                           (type.base base.type.Z)) =>
-                                match a with
-                                | Some x' =>
-                                    if args >? 0
-                                    then
-                                     UnderLets.Base (##(args) - x' v)%expr
-                                    else
+                         | Some args =>
+                             if args =? 0
+                             then UnderLets.Base x
+                             else
+                              match x with
+                              | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
+                                  match
+                                    match idc0 with
+                                    | ident.Z_opp => Some tt
+                                    | _ => None
+                                    end
+                                  with
+                                  | Some _ =>
+                                      match
+                                        s as t2
+                                        return
+                                          (Compile.value' false t2 ->
+                                           UnderLets.UnderLets base.type
+                                             ident var
+                                             (defaults.expr
+                                                (type.base base.type.Z)))
+                                      with
+                                      | type.base t2 =>
+                                          fun
+                                            v : defaults.expr (type.base t2)
+                                          =>
+                                          base.try_make_transport_cps
+                                            (fun t1 : base.type =>
+                                             defaults.expr (type.base t1)) t2
+                                            base.type.Z
+                                            (UnderLets.UnderLets base.type
+                                               ident var
+                                               (defaults.expr
+                                                  (type.base base.type.Z)))
+                                            (fun
+                                               a : option
+                                                     (defaults.expr
+                                                        (type.base t2) ->
+                                                      defaults.expr
+                                                        (type.base
+                                                           base.type.Z)) =>
+                                             match a with
+                                             | Some x' =>
+                                                 if args >? 0
+                                                 then
+                                                  UnderLets.Base
+                                                    (##(args) - x' v)%expr
+                                                 else
+                                                  match
+                                                    s as t3
+                                                    return
+                                                      (Compile.value' false
+                                                         t3 ->
+                                                       UnderLets.UnderLets
+                                                         base.type ident var
+                                                         (defaults.expr
+                                                            (type.base
+                                                               base.type.Z)))
+                                                  with
+                                                  | type.base t3 =>
+                                                      fun
+                                                        v0 : defaults.expr
+                                                               (type.base t3)
+                                                      =>
+                                                      base.try_make_transport_cps
+                                                        (fun t1 : base.type
+                                                         =>
+                                                         defaults.expr
+                                                           (type.base t1)) t3
+                                                        base.type.Z
+                                                        (UnderLets.UnderLets
+                                                           base.type ident
+                                                           var
+                                                           (defaults.expr
+                                                              (type.base
+                                                                 base.type.Z)))
+                                                        (fun
+                                                           a0 : option
+                                                                  (defaults.expr
+                                                                    (type.base
+                                                                    t3) ->
+                                                                   defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                         =>
+                                                         match a0 with
+                                                         | Some x'0 =>
+                                                             if args <? 0
+                                                             then
+                                                              UnderLets.Base
+                                                                (-
+                                                                 (x'0 v0 +
+                                                                  ##((- args)%Z)))%expr
+                                                             else default
+                                                         | None => default
+                                                         end)
+                                                  | (s0 -> d0)%ptype =>
+                                                      fun
+                                                        _ : Compile.value'
+                                                              false s0 ->
+                                                            Compile.value'
+                                                              true d0 =>
+                                                      default
+                                                  end (Compile.reflect x1)
+                                             | None => default
+                                             end)
+                                      | (s0 -> d0)%ptype =>
+                                          fun
+                                            _ : Compile.value' false s0 ->
+                                                Compile.value' true d0 =>
+                                          default
+                                      end (Compile.reflect x1)
+                                  | None => default
+                                  end
+                              | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _
+                                _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                                _ _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _
+                                _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
+                                  default
+                              | _ => default
+                              end
+                         | None => default0 tt
+                         end
+                     | @expr.App _ _ _ s _ #(idc)%expr_pat x1 =>
+                         match
+                           match idc with
+                           | ident.Z_opp => Some tt
+                           | _ => None
+                           end
+                         with
+                         | Some _ =>
+                             match x with
+                             | #(idc0)%expr_pat =>
+                                 match
+                                   match idc0 with
+                                   | @ident.Literal t1 v =>
+                                       match
+                                         t1 as t2
+                                         return
+                                           (base.base_interp t2 -> option Z)
+                                       with
+                                       | base.type.unit =>
+                                           fun _ : unit => None
+                                       | base.type.Z => fun v0 : Z => Some v0
+                                       | base.type.bool =>
+                                           fun _ : bool => None
+                                       | base.type.nat => fun _ : nat => None
+                                       end v
+                                   | _ => None
+                                   end
+                                 with
+                                 | Some args0 =>
                                      match
-                                       s as t3
+                                       s as t2
                                        return
-                                         (Compile.value' false t3 ->
+                                         (Compile.value' false t2 ->
                                           UnderLets.UnderLets base.type ident
                                             var
                                             (defaults.expr
                                                (type.base base.type.Z)))
                                      with
-                                     | type.base t3 =>
-                                         fun
-                                           v0 : defaults.expr (type.base t3)
+                                     | type.base t2 =>
+                                         fun v : defaults.expr (type.base t2)
                                          =>
                                          base.try_make_transport_cps
                                            (fun t1 : base.type =>
-                                            defaults.expr (type.base t1)) t3
+                                            defaults.expr (type.base t1)) t2
                                            base.type.Z
                                            (UnderLets.UnderLets base.type
                                               ident var
                                               (defaults.expr
                                                  (type.base base.type.Z)))
                                            (fun
-                                              a0 : option
-                                                     (defaults.expr
-                                                        (type.base t3) ->
-                                                      defaults.expr
-                                                        (type.base
-                                                           base.type.Z)) =>
-                                            match a0 with
-                                            | Some x'0 =>
-                                                if args <? 0
+                                              a : option
+                                                    (defaults.expr
+                                                       (type.base t2) ->
+                                                     defaults.expr
+                                                       (type.base base.type.Z))
+                                            =>
+                                            match a with
+                                            | Some x' =>
+                                                if args0 >? 0
                                                 then
                                                  UnderLets.Base
-                                                   (-
-                                                    (x'0 v0 + ##((- args)%Z)))%expr
+                                                   (##(args0) - x' v)%expr
                                                 else
                                                  match
-                                                   s as t4
+                                                   s as t3
                                                    return
-                                                     (Compile.value' false t4 ->
+                                                     (Compile.value' false t3 ->
                                                       UnderLets.UnderLets
                                                         base.type ident var
                                                         (defaults.expr
                                                            (type.base
                                                               base.type.Z)))
                                                  with
-                                                 | type.base t4 =>
+                                                 | type.base t3 =>
                                                      fun
-                                                       v1 : defaults.expr
-                                                              (type.base t4)
+                                                       v0 : defaults.expr
+                                                              (type.base t3)
                                                      =>
                                                      base.try_make_transport_cps
                                                        (fun t1 : base.type =>
                                                         defaults.expr
-                                                          (type.base t1)) t4
+                                                          (type.base t1)) t3
                                                        base.type.Z
                                                        (UnderLets.UnderLets
                                                           base.type ident var
@@ -845,21 +794,24 @@ match idc in (ident t) return (Compile.value' true t) with
                                                              (type.base
                                                                 base.type.Z)))
                                                        (fun
-                                                          a1 : option
+                                                          a0 : option
                                                                  (defaults.expr
                                                                     (type.base
-                                                                    t4) ->
+                                                                    t3) ->
                                                                   defaults.expr
                                                                     (type.base
                                                                     base.type.Z))
                                                         =>
-                                                        match a1 with
-                                                        | Some x'1 =>
-                                                            UnderLets.Base
-                                                              (x0 - x'1 v1)%expr
-                                                        | None =>
-                                                            UnderLets.Base
-                                                              (x + x0)%expr
+                                                        match a0 with
+                                                        | Some x'0 =>
+                                                            if args0 <? 0
+                                                            then
+                                                             UnderLets.Base
+                                                               (-
+                                                                (##((- args0)%Z) +
+                                                                 x'0 v0))%expr
+                                                            else default
+                                                        | None => default
                                                         end)
                                                  | (s0 -> d0)%ptype =>
                                                      fun
@@ -867,645 +819,128 @@ match idc in (ident t) return (Compile.value' true t) with
                                                              false s0 ->
                                                            Compile.value'
                                                              true d0 =>
-                                                     UnderLets.Base
-                                                       (x + x0)%expr
+                                                     default
                                                  end (Compile.reflect x1)
-                                            | None =>
-                                                UnderLets.Base (x + x0)%expr
+                                            | None => default
                                             end)
                                      | (s0 -> d0)%ptype =>
                                          fun
                                            _ : Compile.value' false s0 ->
                                                Compile.value' true d0 =>
-                                         UnderLets.Base (x + x0)%expr
+                                         default
                                      end (Compile.reflect x1)
-                                | None => UnderLets.Base (x + x0)%expr
-                                end)
-                         | (s0 -> d0)%ptype =>
-                             fun
-                               _ : Compile.value' false s0 ->
-                                   Compile.value' true d0 =>
-                             UnderLets.Base (x + x0)%expr
-                         end (Compile.reflect x1)
-                     | None => UnderLets.Base (x + x0)%expr
-                     end
-                 | _ => UnderLets.Base (x + x0)%expr
-                 end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' => UnderLets.Base (x0 - x' v)%expr
-                               | None => UnderLets.Base (x + x0)%expr
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base (x + x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x + x0)%expr
-                    end
-                | _ => UnderLets.Base (x + x0)%expr
-                end
-            end
-        | ($_)%expr =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v0)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.Abs _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s0 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base base.type.Z)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
+                                 | None => default
+                                 end
+                             | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x2 =>
+                                 match
+                                   match idc0 with
+                                   | ident.Z_opp => Some tt
+                                   | _ => None
+                                   end
+                                 with
+                                 | Some _ =>
+                                     match
+                                       s0 as t2
+                                       return
+                                         (Compile.value' false t2 ->
+                                          UnderLets.UnderLets base.type ident
                                             var
                                             (defaults.expr
                                                (type.base base.type.Z)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.Base
-                                                (- (x' v + x'0 v0))%expr
-                                          | None =>
-                                              UnderLets.Base (x + x0)%expr
-                                          end)
-                                   | (s1 -> d1)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s1 ->
-                                             Compile.value' true d1 =>
-                                       UnderLets.Base (x + x0)%expr
-                                   end (Compile.reflect x2)
-                               | None => UnderLets.Base (x + x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x + x0)%expr
-                        end (Compile.reflect x1)
-                    | None =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' => UnderLets.Base (x - x' v)%expr
-                               | None => UnderLets.Base (x + x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x + x0)%expr
-                        end (Compile.reflect x2)
-                    end
-                | ($_)%expr =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x - x' v0)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x2)
-                | @expr.LetIn _ _ _ _ _ _ _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x2)
-                | _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x2)
-                end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' => UnderLets.Base (x0 - x' v)%expr
-                               | None => UnderLets.Base (x + x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x + x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x + x0)%expr
-                    end
-                | _ => UnderLets.Base (x + x0)%expr
-                end
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v0)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.LetIn _ _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x0 - x' v)%expr
-                           | None => UnderLets.Base (x + x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x + x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x + x0)%expr
-                end
-            | _ => UnderLets.Base (x + x0)%expr
-            end
-        end
-    | @expr.LetIn _ _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else UnderLets.Base (x + x0)%expr
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x - x' v)%expr
-                       | None => UnderLets.Base (x + x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x + x0)%expr
-                end (Compile.reflect x2)
-            | None => UnderLets.Base (x + x0)%expr
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x + x0)%expr
-        | _ => UnderLets.Base (x + x0)%expr
-        end
-    end
-| ident.Z_mul =>
-    fun x x0 : defaults.expr (type.base base.type.Z) =>
+                                     with
+                                     | type.base t2 =>
+                                         fun v : defaults.expr (type.base t2)
+                                         =>
+                                         base.try_make_transport_cps
+                                           (fun t1 : base.type =>
+                                            defaults.expr (type.base t1)) t2
+                                           base.type.Z
+                                           (UnderLets.UnderLets base.type
+                                              ident var
+                                              (defaults.expr
+                                                 (type.base base.type.Z)))
+                                           (fun
+                                              a : option
+                                                    (defaults.expr
+                                                       (type.base t2) ->
+                                                     defaults.expr
+                                                       (type.base base.type.Z))
+                                            =>
+                                            match a with
+                                            | Some x' =>
+                                                match
+                                                  s as t3
+                                                  return
+                                                    (Compile.value' false t3 ->
+                                                     UnderLets.UnderLets
+                                                       base.type ident var
+                                                       (defaults.expr
+                                                          (type.base
+                                                             base.type.Z)))
+                                                with
+                                                | type.base t3 =>
+                                                    fun
+                                                      v0 : defaults.expr
+                                                             (type.base t3)
+                                                    =>
+                                                    base.try_make_transport_cps
+                                                      (fun t1 : base.type =>
+                                                       defaults.expr
+                                                         (type.base t1)) t3
+                                                      base.type.Z
+                                                      (UnderLets.UnderLets
+                                                         base.type ident var
+                                                         (defaults.expr
+                                                            (type.base
+                                                               base.type.Z)))
+                                                      (fun
+                                                         a0 : option
+                                                                (defaults.expr
+                                                                   (type.base
+                                                                    t3) ->
+                                                                 defaults.expr
+                                                                   (type.base
+                                                                    base.type.Z))
+                                                       =>
+                                                       match a0 with
+                                                       | Some x'0 =>
+                                                           UnderLets.Base
+                                                             (-
+                                                              (x' v + x'0 v0))%expr
+                                                       | None => default
+                                                       end)
+                                                | (s1 -> d1)%ptype =>
+                                                    fun
+                                                      _ : Compile.value'
+                                                            false s1 ->
+                                                          Compile.value' true
+                                                            d1 => default
+                                                end (Compile.reflect x1)
+                                            | None => default
+                                            end)
+                                     | (s1 -> d1)%ptype =>
+                                         fun
+                                           _ : Compile.value' false s1 ->
+                                               Compile.value' true d1 =>
+                                         default
+                                     end (Compile.reflect x2)
+                                 | None => default
+                                 end
+                             | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _
+                               _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                               _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _
+                               _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
+                                 default
+                             | _ => default
+                             end
+                         | None => default
+                         end
+                     | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+                       (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
+                       (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
+                       (@expr.LetIn _ _ _ _ _ _ _) _ => default
+                     | _ => default0 tt
+                     end in
     match x with
     | #(idc)%expr_pat =>
         match
@@ -1520,1206 +955,1045 @@ match idc in (ident t) return (Compile.value' true t) with
           | _ => None
           end
         with
-        | Some args =>
-            if args =? 0
-            then UnderLets.Base ##(0)%expr
-            else
-             match x0 with
-             | #(idc0)%expr_pat =>
-                 match
-                   match idc0 with
-                   | @ident.Literal t1 v =>
-                       match
-                         t1 as t2 return (base.base_interp t2 -> option Z)
-                       with
-                       | base.type.unit => fun _ : unit => None
-                       | base.type.Z => fun v0 : Z => Some v0
-                       | base.type.bool => fun _ : bool => None
-                       | base.type.nat => fun _ : nat => None
-                       end v
-                   | _ => None
-                   end
-                 with
-                 | Some args0 =>
-                     if args0 =? 0
-                     then UnderLets.Base ##(0)%expr
-                     else
-                      if args =? 1
-                      then UnderLets.Base x0
-                      else
-                       if args0 =? 1
-                       then UnderLets.Base x
-                       else
-                        if args =? -1
-                        then UnderLets.Base (- x0)%expr
-                        else
-                         if args0 =? -1
-                         then UnderLets.Base (- x)%expr
-                         else
-                          if args <? 0
-                          then UnderLets.Base (- (##((- args)%Z) * x0))%expr
-                          else
-                           if args0 <? 0
-                           then UnderLets.Base (- (x * ##((- args0)%Z)))%expr
-                           else
-                            if
-                             (args0 =? 2 ^ Z.log2 args0) && negb (args0 =? 2)
-                            then UnderLets.Base (x << ##(Z.log2 args0))%expr
-                            else
-                             if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                             then UnderLets.Base (x0 << ##(Z.log2 args))%expr
-                             else UnderLets.Base (x * x0)%expr
-                 | None =>
-                     if args =? 1
-                     then UnderLets.Base x0
-                     else
-                      if args =? -1
-                      then UnderLets.Base (- x0)%expr
-                      else
-                       if args <? 0
-                       then UnderLets.Base (- (##((- args)%Z) * x0))%expr
-                       else
-                        if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                        then UnderLets.Base (x0 << ##(Z.log2 args))%expr
-                        else UnderLets.Base (x * x0)%expr
-                 end
-             | @expr.App _ _ _ s _ f x1 =>
-                 if args =? 1
-                 then UnderLets.Base x0
-                 else
-                  match f with
-                  | #(idc0)%expr_pat =>
-                      match
-                        match idc0 with
-                        | ident.Z_opp => Some tt
-                        | _ => None
-                        end
-                      with
-                      | Some _ =>
-                          match
-                            s as t2
-                            return
-                              (Compile.value' false t2 ->
-                               UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                          with
-                          | type.base t2 =>
-                              fun v : defaults.expr (type.base t2) =>
-                              base.try_make_transport_cps
-                                (fun t1 : base.type =>
-                                 defaults.expr (type.base t1)) t2 base.type.Z
-                                (UnderLets.UnderLets base.type ident var
-                                   (defaults.expr (type.base base.type.Z)))
-                                (fun
-                                   a : option
-                                         (defaults.expr (type.base t2) ->
-                                          defaults.expr
-                                            (type.base base.type.Z)) =>
-                                 match a with
-                                 | Some x' =>
-                                     if args =? -1
-                                     then UnderLets.Base (x' v)
-                                     else
-                                      if args =? -1
-                                      then UnderLets.Base (- x0)%expr
-                                      else
-                                       if args <? 0
-                                       then
-                                        UnderLets.Base
-                                          (- (##((- args)%Z) * x0))%expr
-                                       else
-                                        match
-                                          s as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base base.type.Z)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t1 : base.type =>
-                                               defaults.expr (type.base t1))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base base.type.Z)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   UnderLets.Base
-                                                     (- (x * x'0 v0))%expr
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (x * x0)%expr
-                                               end)
-                                        | (s0 -> d0)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s0 ->
-                                                  Compile.value' true d0 =>
-                                            UnderLets.Base (x * x0)%expr
-                                        end (Compile.reflect x1)
-                                 | None => UnderLets.Base (x * x0)%expr
-                                 end)
-                          | (s0 -> d0)%ptype =>
-                              fun
-                                _ : Compile.value' false s0 ->
-                                    Compile.value' true d0 =>
-                              UnderLets.Base (x * x0)%expr
-                          end (Compile.reflect x1)
-                      | None =>
-                          if args =? -1
-                          then UnderLets.Base (- x0)%expr
-                          else
-                           if args <? 0
-                           then UnderLets.Base (- (##((- args)%Z) * x0))%expr
-                           else
-                            if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                            then UnderLets.Base (x0 << ##(Z.log2 args))%expr
-                            else UnderLets.Base (x * x0)%expr
-                      end
-                  | _ =>
-                      if args =? -1
-                      then UnderLets.Base (- x0)%expr
-                      else
-                       if args <? 0
-                       then UnderLets.Base (- (##((- args)%Z) * x0))%expr
-                       else
-                        if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                        then UnderLets.Base (x0 << ##(Z.log2 args))%expr
-                        else UnderLets.Base (x * x0)%expr
-                  end
-             | _ =>
-                 if args =? 1
-                 then UnderLets.Base x0
-                 else
-                  if args =? -1
-                  then UnderLets.Base (- x0)%expr
-                  else
-                   if args <? 0
-                   then UnderLets.Base (- (##((- args)%Z) * x0))%expr
-                   else
-                    if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                    then UnderLets.Base (x0 << ##(Z.log2 args))%expr
-                    else UnderLets.Base (x * x0)%expr
-             end
-        | None =>
-            match x0 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args =? 0
-                    then UnderLets.Base ##(0)%expr
-                    else
-                     if args =? 1
-                     then UnderLets.Base x
-                     else
-                      if args =? -1
-                      then UnderLets.Base (- x)%expr
-                      else
-                       if args <? 0
-                       then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                       else
-                        if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                        then UnderLets.Base (x << ##(Z.log2 args))%expr
-                        else UnderLets.Base (x * x0)%expr
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x * x' v))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ => UnderLets.Base (x * x0)%expr
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        end
-    | ($_)%expr =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else
-                 if args =? 1
-                 then UnderLets.Base x
-                 else
-                  if args =? -1
-                  then UnderLets.Base (- x)%expr
-                  else
-                   if args <? 0
-                   then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                   else
-                    if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                    then UnderLets.Base (x << ##(Z.log2 args))%expr
-                    else UnderLets.Base (x * x0)%expr
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v0 : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t1 : base.type => defaults.expr (type.base t1)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (- (x * x' v0))%expr
-                       | None => UnderLets.Base (x * x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x * x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x * x0)%expr
-        | _ => UnderLets.Base (x * x0)%expr
-        end
-    | @expr.Abs _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else
-                 if args =? 1
-                 then UnderLets.Base x
-                 else
-                  if args =? -1
-                  then UnderLets.Base (- x)%expr
-                  else
-                   if args <? 0
-                   then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                   else
-                    if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                    then UnderLets.Base (x << ##(Z.log2 args))%expr
-                    else UnderLets.Base (x * x0)%expr
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (- (x * x' v))%expr
-                       | None => UnderLets.Base (x * x0)%expr
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    => UnderLets.Base (x * x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _ _ _ s0 _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0 _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x * x0)%expr
-        | _ => UnderLets.Base (x * x0)%expr
-        end
-    | @expr.App _ _ _ s _ f x1 =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else
-                 if args =? 1
-                 then UnderLets.Base x
-                 else
-                  match f with
-                  | #(idc0)%expr_pat =>
-                      match
-                        match idc0 with
-                        | ident.Z_opp => Some tt
-                        | _ => None
-                        end
-                      with
-                      | Some _ =>
-                          match
-                            s as t2
-                            return
-                              (Compile.value' false t2 ->
-                               UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                          with
-                          | type.base t2 =>
-                              fun v : defaults.expr (type.base t2) =>
-                              base.try_make_transport_cps
-                                (fun t1 : base.type =>
-                                 defaults.expr (type.base t1)) t2 base.type.Z
-                                (UnderLets.UnderLets base.type ident var
-                                   (defaults.expr (type.base base.type.Z)))
-                                (fun
-                                   a : option
-                                         (defaults.expr (type.base t2) ->
-                                          defaults.expr
-                                            (type.base base.type.Z)) =>
-                                 match a with
-                                 | Some x' =>
-                                     if args =? -1
-                                     then UnderLets.Base (x' v)
-                                     else
-                                      if args =? -1
-                                      then UnderLets.Base (- x)%expr
-                                      else
-                                       if args <? 0
-                                       then
-                                        UnderLets.Base
-                                          (- (x * ##((- args)%Z)))%expr
-                                       else
-                                        match
-                                          s as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base base.type.Z)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t1 : base.type =>
-                                               defaults.expr (type.base t1))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base base.type.Z)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   UnderLets.Base
-                                                     (- (x'0 v0 * x0))%expr
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (x * x0)%expr
-                                               end)
-                                        | (s0 -> d0)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s0 ->
-                                                  Compile.value' true d0 =>
-                                            UnderLets.Base (x * x0)%expr
-                                        end (Compile.reflect x1)
-                                 | None => UnderLets.Base (x * x0)%expr
-                                 end)
-                          | (s0 -> d0)%ptype =>
-                              fun
-                                _ : Compile.value' false s0 ->
-                                    Compile.value' true d0 =>
-                              UnderLets.Base (x * x0)%expr
-                          end (Compile.reflect x1)
-                      | None =>
-                          if args =? -1
-                          then UnderLets.Base (- x)%expr
-                          else
-                           if args <? 0
-                           then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                           else
-                            if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                            then UnderLets.Base (x << ##(Z.log2 args))%expr
-                            else UnderLets.Base (x * x0)%expr
-                      end
-                  | _ =>
-                      if args =? -1
-                      then UnderLets.Base (- x)%expr
-                      else
-                       if args <? 0
-                       then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                       else
-                        if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                        then UnderLets.Base (x << ##(Z.log2 args))%expr
-                        else UnderLets.Base (x * x0)%expr
-                  end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   UnderLets.Base (- (x' v * x0))%expr
-                               | None => UnderLets.Base (x * x0)%expr
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base (x * x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x * x0)%expr
-                    end
-                | _ => UnderLets.Base (x * x0)%expr
-                end
-            end
-        | ($_)%expr =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v0 * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.Abs _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s0 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base base.type.Z)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base base.type.Z)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.Base
-                                                (x' v * x'0 v0)%expr
-                                          | None =>
-                                              UnderLets.Base (x * x0)%expr
-                                          end)
-                                   | (s1 -> d1)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s1 ->
-                                             Compile.value' true d1 =>
-                                       UnderLets.Base (x * x0)%expr
-                                   end (Compile.reflect x2)
-                               | None => UnderLets.Base (x * x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x * x0)%expr
-                        end (Compile.reflect x1)
-                    | None =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   UnderLets.Base (- (x * x' v))%expr
-                               | None => UnderLets.Base (x * x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x * x0)%expr
-                        end (Compile.reflect x2)
-                    end
-                | ($_)%expr =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x * x' v0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x2)
-                | @expr.LetIn _ _ _ _ _ _ _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x * x' v))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x2)
-                | _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x * x' v))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x2)
-                end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   UnderLets.Base (- (x' v * x0))%expr
-                               | None => UnderLets.Base (x * x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x * x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x * x0)%expr
-                    end
-                | _ => UnderLets.Base (x * x0)%expr
-                end
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v0 * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.LetIn _ _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v * x0))%expr
-                           | None => UnderLets.Base (x * x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x * x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x * x0)%expr
-                end
-            | _ => UnderLets.Base (x * x0)%expr
-            end
-        end
-    | @expr.LetIn _ _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else
-                 if args =? 1
-                 then UnderLets.Base x
-                 else
-                  if args =? -1
-                  then UnderLets.Base (- x)%expr
-                  else
-                   if args <? 0
-                   then UnderLets.Base (- (x * ##((- args)%Z)))%expr
-                   else
-                    if (args =? 2 ^ Z.log2 args) && negb (args =? 2)
-                    then UnderLets.Base (x << ##(Z.log2 args))%expr
-                    else UnderLets.Base (x * x0)%expr
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (- (x * x' v))%expr
-                       | None => UnderLets.Base (x * x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x * x0)%expr
-                end (Compile.reflect x2)
-            | None => UnderLets.Base (x * x0)%expr
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x * x0)%expr
-        | _ => UnderLets.Base (x * x0)%expr
+        | Some args => if args =? 0 then UnderLets.Base x0 else default
+        | None => default0 tt
         end
+    | _ => default0 tt
     end
-| ident.Z_pow =>
-    fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_pow)%expr @ x @ x0)%expr_pat
-| ident.Z_sub =>
+| ident.Z_mul =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (x * x0)%expr in
+    llet default0 := fun 'tt =>
+                     llet default0 := fun 'tt =>
+                                      llet default0 := fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       match x with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if
+                                                                (args =?
+                                                                 2
+                                                                 ^ Z.log2
+                                                                    args) &&
+                                                                negb
+                                                                  (args =? 2)
+                                                               then
+                                                                UnderLets.Base
+                                                                  (x0 <<
+                                                                   ##
+                                                                   (Z.log2
+                                                                    args))%expr
+                                                               else default
+                                                           | None => default
+                                                           end
+                                                       | _ => default
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if
+                                                                (args =?
+                                                                 2
+                                                                 ^ Z.log2
+                                                                    args) &&
+                                                                negb
+                                                                  (args =? 2)
+                                                               then
+                                                                UnderLets.Base
+                                                                  (x <<
+                                                                   ##
+                                                                   (Z.log2
+                                                                    args))%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match
+                                                                 s as t2
+                                                                 return
+                                                                   (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                               with
+                                                               | type.base
+                                                                 t2 =>
+                                                                   fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                   base.try_make_transport_cps
+                                                                    (fun
+                                                                    t0 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t0)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    UnderLets.Base
+                                                                    (-
+                                                                    (x * x' v))%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                               | (s0 -> d0)%ptype =>
+                                                                   fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                   => default
+                                                               end
+                                                                 (Compile.reflect
+                                                                    x1)
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x with
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match
+                                                                 s as t2
+                                                                 return
+                                                                   (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                               with
+                                                               | type.base
+                                                                 t2 =>
+                                                                   fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                   base.try_make_transport_cps
+                                                                    (fun
+                                                                    t0 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t0)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    UnderLets.Base
+                                                                    (-
+                                                                    (x' v *
+                                                                    x0))%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                               | (s0 -> d0)%ptype =>
+                                                                   fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                   => default
+                                                               end
+                                                                 (Compile.reflect
+                                                                    x1)
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args <? 0
+                                                               then
+                                                                UnderLets.Base
+                                                                  (-
+                                                                   (x *
+                                                                    ##
+                                                                    ((- args)%Z)))%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match x with
+                                                               | @expr.App _
+                                                                 _ _ s0 _
+                                                                 #(idc0)%expr_pat
+                                                                 x2 =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | ident.Z_opp =>
+                                                                    Some tt
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    _ =>
+                                                                    match
+                                                                    s0 as t2
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t2 =>
+                                                                    fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    match
+                                                                    s as t3
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t3 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t3 =>
+                                                                    fun
+                                                                    v0 : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t3) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t3
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a0 : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t3) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a0
+                                                                    with
+                                                                    | Some
+                                                                    x'0 =>
+                                                                    UnderLets.Base
+                                                                    (x' v *
+                                                                    x'0 v0)%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s1 ->
+                                                                    d1)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s1 ->
+                                                                    Compile.value'
+                                                                    true d1
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x1)
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s1 ->
+                                                                    d1)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s1 ->
+                                                                    Compile.value'
+                                                                    true d1
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x2)
+                                                                   | None =>
+                                                                    default
+                                                                   end
+                                                               | @expr.App _
+                                                                 _ _ s0 _
+                                                                 ($_)%expr
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (@expr.Abs _
+                                                                  _ _ _ _ _)
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (_ @ _)%expr_pat
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (@expr.LetIn
+                                                                  _ _ _ _ _ _
+                                                                  _) _ =>
+                                                                   default
+                                                               | _ => default
+                                                               end
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args <? 0
+                                                               then
+                                                                UnderLets.Base
+                                                                  (-
+                                                                   (##
+                                                                    ((- args)%Z) *
+                                                                    x0))%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args =? -1
+                                                               then
+                                                                UnderLets.Base
+                                                                  (- x)%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args =? -1
+                                                               then
+                                                                UnderLets.Base
+                                                                  (- x0)%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args =? 1
+                                                               then
+                                                                UnderLets.Base
+                                                                  x
+                                                               else
+                                                                match x with
+                                                                | @expr.App _
+                                                                  _ _ s _
+                                                                  #(idc0)%expr_pat
+                                                                  x1 =>
+                                                                    match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | ident.Z_opp =>
+                                                                    Some tt
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                    with
+                                                                    | Some
+                                                                    _ =>
+                                                                    match
+                                                                    s as t2
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t2 =>
+                                                                    fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    if
+                                                                    args =?
+                                                                    -1
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (x' v)
+                                                                    else
+                                                                    default
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s0 ->
+                                                                    d0)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x1)
+                                                                    | None =>
+                                                                    default
+                                                                    end
+                                                                | @expr.App _
+                                                                  _ _ s _
+                                                                  ($_)%expr
+                                                                  _ |
+                                                                  @expr.App _
+                                                                  _ _ s _
+                                                                  (@expr.Abs
+                                                                   _ _ _ _ _
+                                                                   _) _ |
+                                                                  @expr.App _
+                                                                  _ _ s _
+                                                                  (_ @ _)%expr_pat
+                                                                  _ |
+                                                                  @expr.App _
+                                                                  _ _ s _
+                                                                  (@expr.LetIn
+                                                                   _ _ _ _ _
+                                                                   _ _) _ =>
+                                                                    default
+                                                                | _ =>
+                                                                    default
+                                                                end
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match x with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    match
+                                                                    s as t2
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t2 =>
+                                                                    fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    if
+                                                                    args0 =?
+                                                                    -1
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (x' v)
+                                                                    else
+                                                                    default
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s0 ->
+                                                                    d0)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x1)
+                                                                   | None =>
+                                                                    default
+                                                                   end
+                                                               | _ => default
+                                                               end
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                      match x with
+                                      | #(idc)%expr_pat =>
+                                          match
+                                            match idc with
+                                            | @ident.Literal t0 v =>
+                                                match
+                                                  t0 as t1
+                                                  return
+                                                    (base.base_interp t1 ->
+                                                     option Z)
+                                                with
+                                                | base.type.unit =>
+                                                    fun _ : unit => None
+                                                | base.type.Z =>
+                                                    fun v0 : Z => Some v0
+                                                | base.type.bool =>
+                                                    fun _ : bool => None
+                                                | base.type.nat =>
+                                                    fun _ : nat => None
+                                                end v
+                                            | _ => None
+                                            end
+                                          with
+                                          | Some args =>
+                                              if args =? 1
+                                              then UnderLets.Base x0
+                                              else default
+                                          | None => default0 tt
+                                          end
+                                      | _ => default0 tt
+                                      end in
+                     match x0 with
+                     | #(idc)%expr_pat =>
+                         match
+                           match idc with
+                           | @ident.Literal t0 v =>
+                               match
+                                 t0 as t1
+                                 return (base.base_interp t1 -> option Z)
+                               with
+                               | base.type.unit => fun _ : unit => None
+                               | base.type.Z => fun v0 : Z => Some v0
+                               | base.type.bool => fun _ : bool => None
+                               | base.type.nat => fun _ : nat => None
+                               end v
+                           | _ => None
+                           end
+                         with
+                         | Some args =>
+                             if args =? 0
+                             then UnderLets.Base ##(0)%expr
+                             else default
+                         | None => default0 tt
+                         end
+                     | _ => default0 tt
+                     end in
     match x with
     | #(idc)%expr_pat =>
         match
@@ -2735,753 +2009,846 @@ match idc in (ident t) return (Compile.value' true t) with
           end
         with
         | Some args =>
-            match x0 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args0 =>
-                    if args =? 0
-                    then UnderLets.Base (- x0)%expr
-                    else
-                     if args0 =? 0
-                     then UnderLets.Base x
-                     else
-                      if args <? 0
-                      then UnderLets.Base (- (##((- args)%Z) + x0))%expr
-                      else
-                       if args0 <? 0
-                       then UnderLets.Base (x + ##((- args0)%Z))%expr
-                       else UnderLets.Base (x - x0)%expr
-                | None =>
-                    if args =? 0
-                    then UnderLets.Base (- x0)%expr
-                    else
-                     if args <? 0
-                     then UnderLets.Base (- (##((- args)%Z) + x0))%expr
-                     else UnderLets.Base (x - x0)%expr
-                end
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' =>
-                               if args =? 0
-                               then UnderLets.Base (x' v)
-                               else
-                                if args =? 0
-                                then UnderLets.Base (- x0)%expr
-                                else
-                                 match
-                                   s as t3
-                                   return
-                                     (Compile.value' false t3 ->
-                                      UnderLets.UnderLets base.type ident var
-                                        (defaults.expr
-                                           (type.base base.type.Z)))
-                                 with
-                                 | type.base t3 =>
-                                     fun v0 : defaults.expr (type.base t3) =>
-                                     base.try_make_transport_cps
-                                       (fun t1 : base.type =>
-                                        defaults.expr (type.base t1)) t3
-                                       base.type.Z
-                                       (UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base base.type.Z)))
-                                       (fun
-                                          a0 : option
-                                                 (defaults.expr
-                                                    (type.base t3) ->
-                                                  defaults.expr
-                                                    (type.base base.type.Z))
-                                        =>
-                                        match a0 with
-                                        | Some x'0 =>
-                                            if args >? 0
-                                            then
-                                             UnderLets.Base
-                                               (##(args) + x'0 v0)%expr
-                                            else
-                                             match
-                                               s as t4
-                                               return
-                                                 (Compile.value' false t4 ->
-                                                  UnderLets.UnderLets
-                                                    base.type ident var
-                                                    (defaults.expr
-                                                       (type.base base.type.Z)))
-                                             with
-                                             | type.base t4 =>
-                                                 fun
-                                                   v1 : defaults.expr
-                                                          (type.base t4) =>
-                                                 base.try_make_transport_cps
-                                                   (fun t1 : base.type =>
-                                                    defaults.expr
-                                                      (type.base t1)) t4
-                                                   base.type.Z
-                                                   (UnderLets.UnderLets
-                                                      base.type ident var
-                                                      (defaults.expr
-                                                         (type.base
-                                                            base.type.Z)))
-                                                   (fun
-                                                      a1 : option
-                                                             (defaults.expr
-                                                                (type.base t4) ->
-                                                              defaults.expr
-                                                                (type.base
-                                                                   base.type.Z))
-                                                    =>
-                                                    match a1 with
-                                                    | Some x'1 =>
-                                                        if args <? 0
-                                                        then
-                                                         UnderLets.Base
-                                                           (x'1 v1 -
-                                                            ##((- args)%Z))%expr
-                                                        else
-                                                         if args <? 0
-                                                         then
-                                                          UnderLets.Base
-                                                            (-
-                                                             (##((- args)%Z) +
-                                                              x0))%expr
-                                                         else
-                                                          match
-                                                            s as t5
-                                                            return
-                                                              (Compile.value'
-                                                                 false t5 ->
-                                                               UnderLets.UnderLets
-                                                                 base.type
-                                                                 ident var
-                                                                 (defaults.expr
+            if args =? 0 then UnderLets.Base ##(0)%expr else default
+        | None => default0 tt
+        end
+    | _ => default0 tt
+    end
+| ident.Z_pow =>
+    fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (#(ident.Z_pow)%expr @ x @ x0)%expr_pat in
+    default
+| ident.Z_sub =>
+    fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (x - x0)%expr in
+    llet default0 := fun 'tt =>
+                     llet default0 := fun 'tt =>
+                                      llet default0 := fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       match x0 with
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match
+                                                                 s as t2
+                                                                 return
+                                                                   (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
                                                                     (type.base
                                                                     base.type.Z)))
-                                                          with
-                                                          | type.base t5 =>
-                                                              fun
-                                                                v2 : 
-                                                                 defaults.expr
-                                                                   (type.base
-                                                                    t5) =>
-                                                              base.try_make_transport_cps
-                                                                (fun
-                                                                   t1 : base.type
-                                                                 =>
-                                                                 defaults.expr
-                                                                   (type.base
-                                                                    t1)) t5
-                                                                base.type.Z
-                                                                (UnderLets.UnderLets
-                                                                   base.type
-                                                                   ident var
-                                                                   (defaults.expr
+                                                               with
+                                                               | type.base
+                                                                 t2 =>
+                                                                   fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                   base.try_make_transport_cps
+                                                                    (fun
+                                                                    t0 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t0)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    UnderLets.Base
+                                                                    (x + x' v)%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                               | (s0 -> d0)%ptype =>
+                                                                   fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                   => default
+                                                               end
+                                                                 (Compile.reflect
+                                                                    x1)
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default
+                                                       end in
+                                                       match x with
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match
+                                                                 s as t2
+                                                                 return
+                                                                   (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                               with
+                                                               | type.base
+                                                                 t2 =>
+                                                                   fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                   base.try_make_transport_cps
+                                                                    (fun
+                                                                    t0 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t0)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
                                                                     (type.base
                                                                     base.type.Z)))
-                                                                (fun
-                                                                   a2 : 
+                                                                    (fun
+                                                                    a : 
                                                                     option
                                                                     (defaults.expr
                                                                     (type.base
-                                                                    t5) ->
+                                                                    t2) ->
                                                                     defaults.expr
                                                                     (type.base
                                                                     base.type.Z))
-                                                                 =>
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    UnderLets.Base
+                                                                    (-
+                                                                    (x' v +
+                                                                    x0))%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                               | (s0 -> d0)%ptype =>
+                                                                   fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
+                                                                   => default
+                                                               end
+                                                                 (Compile.reflect
+                                                                    x1)
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
                                                                  match
-                                                                   a2
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
                                                                  with
-                                                                 | Some
-                                                                   x'2 =>
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args <? 0
+                                                               then
+                                                                UnderLets.Base
+                                                                  (x +
+                                                                   ##
+                                                                   ((- args)%Z))%expr
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         #(idc)%expr_pat
+                                                         x1 =>
+                                                           match
+                                                             match idc with
+                                                             | ident.Z_opp =>
+                                                                 Some tt
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some _ =>
+                                                               match x with
+                                                               | @expr.App _
+                                                                 _ _ s0 _
+                                                                 #(idc0)%expr_pat
+                                                                 x2 =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | ident.Z_opp =>
+                                                                    Some tt
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    _ =>
+                                                                    match
+                                                                    s0 as t2
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t2 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t2 =>
+                                                                    fun
+                                                                    v : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t2) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t2
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a
+                                                                    with
+                                                                    | Some
+                                                                    x' =>
+                                                                    match
+                                                                    s as t3
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t3 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    with
+                                                                    | type.base
+                                                                    t3 =>
+                                                                    fun
+                                                                    v0 : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t3) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t3
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a0 : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t3) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a0
+                                                                    with
+                                                                    | Some
+                                                                    x'0 =>
                                                                     UnderLets.Base
-                                                                    (x +
-                                                                    x'2 v2)%expr
-                                                                 | None =>
+                                                                    (x'0 v0 -
+                                                                    x' v)%expr
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s1 ->
+                                                                    d1)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s1 ->
+                                                                    Compile.value'
+                                                                    true d1
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x1)
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s1 ->
+                                                                    d1)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s1 ->
+                                                                    Compile.value'
+                                                                    true d1
+                                                                    =>
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x2)
+                                                                   | None =>
+                                                                    default
+                                                                   end
+                                                               | @expr.App _
+                                                                 _ _ s0 _
+                                                                 ($_)%expr
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (@expr.Abs _
+                                                                  _ _ _ _ _)
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (_ @ _)%expr_pat
+                                                                 _ |
+                                                                 @expr.App _
+                                                                 _ _ s0 _
+                                                                 (@expr.LetIn
+                                                                  _ _ _ _ _ _
+                                                                  _) _ =>
+                                                                   default
+                                                               | _ => default
+                                                               end
+                                                           | None => default
+                                                           end
+                                                       | @expr.App _ _ _ s _
+                                                         ($_)%expr _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.Abs _ _ _ _ _
+                                                          _) _ | @expr.App _
+                                                         _ _ s _
+                                                         (_ @ _)%expr_pat _ |
+                                                         @expr.App _ _ _ s _
+                                                         (@expr.LetIn _ _ _ _
+                                                          _ _ _) _ => default
+                                                       | _ => default0 tt
+                                                       end in
+                                      match x with
+                                      | #(idc)%expr_pat =>
+                                          match
+                                            match idc with
+                                            | @ident.Literal t0 v =>
+                                                match
+                                                  t0 as t1
+                                                  return
+                                                    (base.base_interp t1 ->
+                                                     option Z)
+                                                with
+                                                | base.type.unit =>
+                                                    fun _ : unit => None
+                                                | base.type.Z =>
+                                                    fun v0 : Z => Some v0
+                                                | base.type.bool =>
+                                                    fun _ : bool => None
+                                                | base.type.nat =>
+                                                    fun _ : nat => None
+                                                end v
+                                            | _ => None
+                                            end
+                                          with
+                                          | Some args =>
+                                              if args <? 0
+                                              then
+                                               UnderLets.Base
+                                                 (- (##((- args)%Z) + x0))%expr
+                                              else default
+                                          | None => default0 tt
+                                          end
+                                      | @expr.App _ _ _ s _ #(idc)%expr_pat
+                                        x1 =>
+                                          match
+                                            match idc with
+                                            | ident.Z_opp => Some tt
+                                            | _ => None
+                                            end
+                                          with
+                                          | Some _ =>
+                                              match x0 with
+                                              | #(idc0)%expr_pat =>
+                                                  match
+                                                    match idc0 with
+                                                    | @ident.Literal t1 v =>
+                                                        match
+                                                          t1 as t2
+                                                          return
+                                                            (base.base_interp
+                                                               t2 -> 
+                                                             option Z)
+                                                        with
+                                                        | base.type.unit =>
+                                                            fun _ : unit =>
+                                                            None
+                                                        | base.type.Z =>
+                                                            fun v0 : Z =>
+                                                            Some v0
+                                                        | base.type.bool =>
+                                                            fun _ : bool =>
+                                                            None
+                                                        | base.type.nat =>
+                                                            fun _ : nat =>
+                                                            None
+                                                        end v
+                                                    | _ => None
+                                                    end
+                                                  with
+                                                  | Some args0 =>
+                                                      match
+                                                        s as t2
+                                                        return
+                                                          (Compile.value'
+                                                             false t2 ->
+                                                           UnderLets.UnderLets
+                                                             base.type ident
+                                                             var
+                                                             (defaults.expr
+                                                                (type.base
+                                                                   base.type.Z)))
+                                                      with
+                                                      | type.base t2 =>
+                                                          fun
+                                                            v : defaults.expr
+                                                                  (type.base
+                                                                    t2) =>
+                                                          base.try_make_transport_cps
+                                                            (fun
+                                                               t1 : base.type
+                                                             =>
+                                                             defaults.expr
+                                                               (type.base t1))
+                                                            t2 base.type.Z
+                                                            (UnderLets.UnderLets
+                                                               base.type
+                                                               ident var
+                                                               (defaults.expr
+                                                                  (type.base
+                                                                    base.type.Z)))
+                                                            (fun
+                                                               a : option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                             =>
+                                                             match a with
+                                                             | Some x' =>
+                                                                 if
+                                                                  args0 >? 0
+                                                                 then
+                                                                  UnderLets.Base
+                                                                    (-
+                                                                    (x' v +
+                                                                    ##
+                                                                    ((- args0)%Z)))%expr
+                                                                 else
+                                                                  match
+                                                                    s as t3
+                                                                    return
+                                                                    (Compile.value'
+                                                                    false t3 ->
+                                                                    UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                  with
+                                                                  | type.base
+                                                                    t3 =>
+                                                                    fun
+                                                                    v0 : 
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t3) =>
+                                                                    base.try_make_transport_cps
+                                                                    (fun
+                                                                    t1 : base.type
+                                                                    =>
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    t1)) t3
+                                                                    base.type.Z
+                                                                    (UnderLets.UnderLets
+                                                                    base.type
+                                                                    ident var
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z)))
+                                                                    (fun
+                                                                    a0 : 
+                                                                    option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t3) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                                    =>
+                                                                    match
+                                                                    a0
+                                                                    with
+                                                                    | Some
+                                                                    x'0 =>
+                                                                    if
+                                                                    args0 <?
+                                                                    0
+                                                                    then
                                                                     UnderLets.Base
-                                                                    (x - x0)%expr
-                                                                 end)
-                                                          | (s0 -> d0)%ptype =>
-                                                              fun
-                                                                _ : Compile.value'
+                                                                    (##
+                                                                    ((- args0)%Z) -
+                                                                    x'0 v0)%expr
+                                                                    else
+                                                                    default
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                  | (s0 -> d0)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
                                                                     false s0 ->
                                                                     Compile.value'
                                                                     true d0
-                                                              =>
-                                                              UnderLets.Base
-                                                                (x - x0)%expr
-                                                          end
-                                                            (Compile.reflect
-                                                               x1)
-                                                    | None =>
-                                                        UnderLets.Base
-                                                          (x - x0)%expr
-                                                    end)
-                                             | (s0 -> d0)%ptype =>
-                                                 fun
-                                                   _ : Compile.value' false
-                                                         s0 ->
-                                                       Compile.value' true d0
-                                                 =>
-                                                 UnderLets.Base (x - x0)%expr
-                                             end (Compile.reflect x1)
-                                        | None =>
-                                            UnderLets.Base (x - x0)%expr
-                                        end)
-                                 | (s0 -> d0)%ptype =>
-                                     fun
-                                       _ : Compile.value' false s0 ->
-                                           Compile.value' true d0 =>
-                                     UnderLets.Base (x - x0)%expr
-                                 end (Compile.reflect x1)
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None =>
-                    if args =? 0
-                    then UnderLets.Base (- x0)%expr
-                    else
-                     if args <? 0
-                     then UnderLets.Base (- (##((- args)%Z) + x0))%expr
-                     else UnderLets.Base (x - x0)%expr
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                if args =? 0
-                then UnderLets.Base (- x0)%expr
-                else
-                 if args <? 0
-                 then UnderLets.Base (- (##((- args)%Z) + x0))%expr
-                 else UnderLets.Base (x - x0)%expr
-            | _ =>
-                if args =? 0
-                then UnderLets.Base (- x0)%expr
-                else
-                 if args <? 0
-                 then UnderLets.Base (- (##((- args)%Z) + x0))%expr
-                 else UnderLets.Base (x - x0)%expr
-            end
-        | None =>
-            match x0 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args =? 0
-                    then UnderLets.Base x
-                    else
-                     if args <? 0
-                     then UnderLets.Base (x + ##((- args)%Z))%expr
-                     else UnderLets.Base (x - x0)%expr
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x + x' v)%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ => UnderLets.Base (x - x0)%expr
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        end
-    | ($_)%expr =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else
-                 if args <? 0
-                 then UnderLets.Base (x + ##((- args)%Z))%expr
-                 else UnderLets.Base (x - x0)%expr
-            | None => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v0 : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t1 : base.type => defaults.expr (type.base t1)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x + x' v0)%expr
-                       | None => UnderLets.Base (x - x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x - x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x - x0)%expr
-        | _ => UnderLets.Base (x - x0)%expr
-        end
-    | @expr.Abs _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else
-                 if args <? 0
-                 then UnderLets.Base (x + ##((- args)%Z))%expr
-                 else UnderLets.Base (x - x0)%expr
-            | None => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x1 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x + x' v)%expr
-                       | None => UnderLets.Base (x - x0)%expr
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    => UnderLets.Base (x - x0)%expr
-                end (Compile.reflect x1)
-            | None => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _ _ _ s0 _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0 _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x - x0)%expr
-        | _ => UnderLets.Base (x - x0)%expr
-        end
-    | @expr.App _ _ _ s _ f x1 =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else
-                 match f with
-                 | #(idc0)%expr_pat =>
-                     match
-                       match idc0 with
-                       | ident.Z_opp => Some tt
-                       | _ => None
-                       end
-                     with
-                     | Some _ =>
+                                                                    =>
+                                                                    default
+                                                                  end
+                                                                    (Compile.reflect
+                                                                    x1)
+                                                             | None =>
+                                                                 default
+                                                             end)
+                                                      | (s0 -> d0)%ptype =>
+                                                          fun
+                                                            _ : Compile.value'
+                                                                  false s0 ->
+                                                                Compile.value'
+                                                                  true d0 =>
+                                                          default
+                                                      end
+                                                        (Compile.reflect x1)
+                                                  | None => default
+                                                  end
+                                              | _ => default
+                                              end
+                                          | None => default
+                                          end
+                                      | @expr.App _ _ _ s _ ($_)%expr _ |
+                                        @expr.App _ _ _ s _
+                                        (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                                        _ _ _ s _ (_ @ _)%expr_pat _ |
+                                        @expr.App _ _ _ s _
+                                        (@expr.LetIn _ _ _ _ _ _ _) _ =>
+                                          default
+                                      | _ => default0 tt
+                                      end in
+                     match x0 with
+                     | #(idc)%expr_pat =>
+                         match
+                           match idc with
+                           | @ident.Literal t0 v =>
+                               match
+                                 t0 as t1
+                                 return (base.base_interp t1 -> option Z)
+                               with
+                               | base.type.unit => fun _ : unit => None
+                               | base.type.Z => fun v0 : Z => Some v0
+                               | base.type.bool => fun _ : bool => None
+                               | base.type.nat => fun _ : nat => None
+                               end v
+                           | _ => None
+                           end
+                         with
+                         | Some args =>
+                             if args =? 0 then UnderLets.Base x else default
+                         | None => default0 tt
+                         end
+                     | @expr.App _ _ _ s _ #(idc)%expr_pat x1 =>
                          match
-                           s as t2
-                           return
-                             (Compile.value' false t2 ->
-                              UnderLets.UnderLets base.type ident var
-                                (defaults.expr (type.base base.type.Z)))
+                           match idc with
+                           | ident.Z_opp => Some tt
+                           | _ => None
+                           end
                          with
-                         | type.base t2 =>
-                             fun v : defaults.expr (type.base t2) =>
-                             base.try_make_transport_cps
-                               (fun t1 : base.type =>
-                                defaults.expr (type.base t1)) t2 base.type.Z
-                               (UnderLets.UnderLets base.type ident var
-                                  (defaults.expr (type.base base.type.Z)))
-                               (fun
-                                  a : option
-                                        (defaults.expr (type.base t2) ->
-                                         defaults.expr
-                                           (type.base base.type.Z)) =>
-                                match a with
-                                | Some x' =>
-                                    if args >? 0
-                                    then
-                                     UnderLets.Base
-                                       (- (x' v + ##((- args)%Z)))%expr
-                                    else
+                         | Some _ =>
+                             match x with
+                             | #(idc0)%expr_pat =>
+                                 match
+                                   match idc0 with
+                                   | @ident.Literal t1 v =>
+                                       match
+                                         t1 as t2
+                                         return
+                                           (base.base_interp t2 -> option Z)
+                                       with
+                                       | base.type.unit =>
+                                           fun _ : unit => None
+                                       | base.type.Z => fun v0 : Z => Some v0
+                                       | base.type.bool =>
+                                           fun _ : bool => None
+                                       | base.type.nat => fun _ : nat => None
+                                       end v
+                                   | _ => None
+                                   end
+                                 with
+                                 | Some args0 =>
                                      match
-                                       s as t3
+                                       s as t2
                                        return
-                                         (Compile.value' false t3 ->
+                                         (Compile.value' false t2 ->
                                           UnderLets.UnderLets base.type ident
                                             var
                                             (defaults.expr
                                                (type.base base.type.Z)))
                                      with
-                                     | type.base t3 =>
-                                         fun
-                                           v0 : defaults.expr (type.base t3)
+                                     | type.base t2 =>
+                                         fun v : defaults.expr (type.base t2)
                                          =>
                                          base.try_make_transport_cps
                                            (fun t1 : base.type =>
-                                            defaults.expr (type.base t1)) t3
+                                            defaults.expr (type.base t1)) t2
                                            base.type.Z
                                            (UnderLets.UnderLets base.type
                                               ident var
                                               (defaults.expr
                                                  (type.base base.type.Z)))
                                            (fun
-                                              a0 : option
-                                                     (defaults.expr
-                                                        (type.base t3) ->
-                                                      defaults.expr
-                                                        (type.base
-                                                           base.type.Z)) =>
-                                            match a0 with
-                                            | Some x'0 =>
-                                                if args <? 0
+                                              a : option
+                                                    (defaults.expr
+                                                       (type.base t2) ->
+                                                     defaults.expr
+                                                       (type.base base.type.Z))
+                                            =>
+                                            match a with
+                                            | Some x' =>
+                                                if args0 >? 0
                                                 then
                                                  UnderLets.Base
-                                                   (##((- args)%Z) - x'0 v0)%expr
+                                                   (##(args0) + x' v)%expr
                                                 else
-                                                 if args <? 0
-                                                 then
-                                                  UnderLets.Base
-                                                    (x + ##((- args)%Z))%expr
-                                                 else
-                                                  match
-                                                    s as t4
-                                                    return
-                                                      (Compile.value' false
-                                                         t4 ->
-                                                       UnderLets.UnderLets
-                                                         base.type ident var
-                                                         (defaults.expr
-                                                            (type.base
-                                                               base.type.Z)))
-                                                  with
-                                                  | type.base t4 =>
-                                                      fun
-                                                        v1 : defaults.expr
-                                                               (type.base t4)
-                                                      =>
-                                                      base.try_make_transport_cps
-                                                        (fun t1 : base.type
-                                                         =>
-                                                         defaults.expr
-                                                           (type.base t1)) t4
-                                                        base.type.Z
-                                                        (UnderLets.UnderLets
-                                                           base.type ident
-                                                           var
-                                                           (defaults.expr
-                                                              (type.base
-                                                                 base.type.Z)))
-                                                        (fun
-                                                           a1 : option
-                                                                  (defaults.expr
+                                                 match
+                                                   s as t3
+                                                   return
+                                                     (Compile.value' false t3 ->
+                                                      UnderLets.UnderLets
+                                                        base.type ident var
+                                                        (defaults.expr
+                                                           (type.base
+                                                              base.type.Z)))
+                                                 with
+                                                 | type.base t3 =>
+                                                     fun
+                                                       v0 : defaults.expr
+                                                              (type.base t3)
+                                                     =>
+                                                     base.try_make_transport_cps
+                                                       (fun t1 : base.type =>
+                                                        defaults.expr
+                                                          (type.base t1)) t3
+                                                       base.type.Z
+                                                       (UnderLets.UnderLets
+                                                          base.type ident var
+                                                          (defaults.expr
+                                                             (type.base
+                                                                base.type.Z)))
+                                                       (fun
+                                                          a0 : option
+                                                                 (defaults.expr
                                                                     (type.base
-                                                                    t4) ->
-                                                                   defaults.expr
+                                                                    t3) ->
+                                                                  defaults.expr
                                                                     (type.base
                                                                     base.type.Z))
-                                                         =>
-                                                         match a1 with
-                                                         | Some x'1 =>
-                                                             UnderLets.Base
-                                                               (-
-                                                                (x'1 v1 + x0))%expr
-                                                         | None =>
+                                                        =>
+                                                        match a0 with
+                                                        | Some x'0 =>
+                                                            if args0 <? 0
+                                                            then
                                                              UnderLets.Base
-                                                               (x - x0)%expr
-                                                         end)
-                                                  | (s0 -> d0)%ptype =>
-                                                      fun
-                                                        _ : Compile.value'
-                                                              false s0 ->
-                                                            Compile.value'
-                                                              true d0 =>
-                                                      UnderLets.Base
-                                                        (x - x0)%expr
-                                                  end (Compile.reflect x1)
-                                            | None =>
-                                                UnderLets.Base (x - x0)%expr
+                                                               (x'0 v0 -
+                                                                ##((- args0)%Z))%expr
+                                                            else default
+                                                        | None => default
+                                                        end)
+                                                 | (s0 -> d0)%ptype =>
+                                                     fun
+                                                       _ : Compile.value'
+                                                             false s0 ->
+                                                           Compile.value'
+                                                             true d0 =>
+                                                     default
+                                                 end (Compile.reflect x1)
+                                            | None => default
                                             end)
                                      | (s0 -> d0)%ptype =>
                                          fun
                                            _ : Compile.value' false s0 ->
                                                Compile.value' true d0 =>
-                                         UnderLets.Base (x - x0)%expr
+                                         default
                                      end (Compile.reflect x1)
-                                | None => UnderLets.Base (x - x0)%expr
-                                end)
-                         | (s0 -> d0)%ptype =>
-                             fun
-                               _ : Compile.value' false s0 ->
-                                   Compile.value' true d0 =>
-                             UnderLets.Base (x - x0)%expr
-                         end (Compile.reflect x1)
-                     | None =>
-                         if args <? 0
-                         then UnderLets.Base (x + ##((- args)%Z))%expr
-                         else UnderLets.Base (x - x0)%expr
-                     end
-                 | _ =>
-                     if args <? 0
-                     then UnderLets.Base (x + ##((- args)%Z))%expr
-                     else UnderLets.Base (x - x0)%expr
-                 end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   UnderLets.Base (- (x' v + x0))%expr
-                               | None => UnderLets.Base (x - x0)%expr
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base (x - x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x - x0)%expr
-                    end
-                | _ => UnderLets.Base (x - x0)%expr
-                end
-            end
-        | ($_)%expr =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v0 + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.Abs _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
+                                 | None => default
+                                 end
+                             | _ => default
+                             end
+                         | None => default
+                         end
+                     | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+                       (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
+                       (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
+                       (@expr.LetIn _ _ _ _ _ _ _) _ => default
+                     | _ => default0 tt
+                     end in
+    match x with
+    | #(idc)%expr_pat =>
+        match
+          match idc with
+          | @ident.Literal t0 v =>
+              match t0 as t1 return (base.base_interp t1 -> option Z) with
+              | base.type.unit => fun _ : unit => None
+              | base.type.Z => fun v0 : Z => Some v0
+              | base.type.bool => fun _ : bool => None
+              | base.type.nat => fun _ : nat => None
+              end v
+          | _ => None
+          end
+        with
+        | Some args =>
+            llet default1 := fun 'tt =>
+                             if args =? 0
+                             then UnderLets.Base (- x0)%expr
+                             else default in
+            match x0 with
+            | @expr.App _ _ _ s _ #(idc0)%expr_pat x1 =>
                 match
-                  match idc with
+                  match idc0 with
                   | ident.Z_opp => Some tt
                   | _ => None
                   end
@@ -3497,156 +2864,6 @@ match idc in (ident t) return (Compile.value' true t) with
                     | type.base t2 =>
                         fun v : defaults.expr (type.base t2) =>
                         base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s0 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base base.type.Z)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base base.type.Z)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.Base
-                                                (x'0 v0 - x' v)%expr
-                                          | None =>
-                                              UnderLets.Base (x - x0)%expr
-                                          end)
-                                   | (s1 -> d1)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s1 ->
-                                             Compile.value' true d1 =>
-                                       UnderLets.Base (x - x0)%expr
-                                   end (Compile.reflect x2)
-                               | None => UnderLets.Base (x - x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x - x0)%expr
-                        end (Compile.reflect x1)
-                    | None =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' => UnderLets.Base (x + x' v)%expr
-                               | None => UnderLets.Base (x - x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x - x0)%expr
-                        end (Compile.reflect x2)
-                    end
-                | ($_)%expr =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
                           (fun t1 : base.type => defaults.expr (type.base t1))
                           t2 base.type.Z
                           (UnderLets.UnderLets base.type ident var
@@ -3656,368 +2873,40 @@ match idc in (ident t) return (Compile.value' true t) with
                                    (defaults.expr (type.base t2) ->
                                     defaults.expr (type.base base.type.Z)) =>
                            match a with
-                           | Some x' => UnderLets.Base (x + x' v0)%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x2)
-                | @expr.LetIn _ _ _ _ _ _ _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x + x' v)%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x2)
-                | _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (x + x' v)%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x2)
-                end
-            | None =>
-                match f with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr (type.base base.type.Z)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr (type.base base.type.Z)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   UnderLets.Base (- (x' v + x0))%expr
-                               | None => UnderLets.Base (x - x0)%expr
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base (x - x0)%expr
-                        end (Compile.reflect x1)
-                    | None => UnderLets.Base (x - x0)%expr
-                    end
-                | _ => UnderLets.Base (x - x0)%expr
-                end
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v0 : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v0 + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s2 -> d2)%ptype =>
-                        fun
-                          _ : Compile.value' false s2 ->
-                              Compile.value' true d2 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base (x - x0)%expr
-                    end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
-                end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.LetIn _ _ _ _ _ _ _ =>
-            match f with
-            | #(idc)%expr_pat =>
-                match
-                  match idc with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr (type.base base.type.Z)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t0 : base.type => defaults.expr (type.base t0))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr (type.base base.type.Z)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' => UnderLets.Base (- (x' v + x0))%expr
-                           | None => UnderLets.Base (x - x0)%expr
+                           | Some x' =>
+                               if args =? 0
+                               then UnderLets.Base (x' v)
+                               else default
+                           | None => default
                            end)
                     | (s0 -> d0)%ptype =>
                         fun
                           _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base (x - x0)%expr
+                              Compile.value' true d0 => default
                     end (Compile.reflect x1)
-                | None => UnderLets.Base (x - x0)%expr
+                | None => default
                 end
-            | _ => UnderLets.Base (x - x0)%expr
-            end
-        end
-    | @expr.LetIn _ _ _ _ _ _ _ =>
-        match x0 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base x
-                else
-                 if args <? 0
-                 then UnderLets.Base (x + ##((- args)%Z))%expr
-                 else UnderLets.Base (x - x0)%expr
-            | None => UnderLets.Base (x - x0)%expr
-            end
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr (type.base base.type.Z)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr (type.base base.type.Z)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' => UnderLets.Base (x + x' v)%expr
-                       | None => UnderLets.Base (x - x0)%expr
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    => UnderLets.Base (x - x0)%expr
-                end (Compile.reflect x2)
-            | None => UnderLets.Base (x - x0)%expr
+            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
+              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
+              (@expr.LetIn _ _ _ _ _ _ _) _ => default
+            | _ => default1 tt
             end
-        | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
-          (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat
-          _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.Base (x - x0)%expr
-        | _ => UnderLets.Base (x - x0)%expr
+        | None => default0 tt
         end
+    | _ => default0 tt
     end
 | ident.Z_opp =>
     fun x : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (- x)%expr in
+    llet default0 := fun 'tt =>
+                     if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
+                     then
+                      UnderLets.UnderLet x
+                        (fun v : var (type.base base.type.Z) =>
+                         UnderLets.Base (- $v)%expr)
+                     else default in
     match x with
-    | ($_)%expr =>
-        if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
-        then
-         UnderLets.UnderLet x
-           (fun v0 : var (type.base base.type.Z) =>
-            UnderLets.Base (- $v0)%expr)
-        else UnderLets.Base (- x)%expr
     | @expr.App _ _ _ s _ #(idc)%expr_pat x0 =>
         match match idc with
               | ident.Z_opp => Some tt
@@ -4044,44 +2933,22 @@ match idc in (ident t) return (Compile.value' true t) with
                             defaults.expr (type.base base.type.Z)) =>
                    match a with
                    | Some x' => UnderLets.Base (x' v)
-                   | None => UnderLets.Base (- x)%expr
+                   | None => default
                    end)
             | (s0 -> d0)%ptype =>
                 fun _ : Compile.value' false s0 -> Compile.value' true d0 =>
-                UnderLets.Base (- x)%expr
+                default
             end (Compile.reflect x0)
-        | None =>
-            if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
-            then
-             UnderLets.UnderLet x
-               (fun v : var (type.base base.type.Z) =>
-                UnderLets.Base (- $v)%expr)
-            else UnderLets.Base (- x)%expr
+        | None => default
         end
-    | @expr.App _ _ _ s _ ($_)%expr _ =>
-        if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
-        then
-         UnderLets.UnderLet x
-           (fun v0 : var (type.base base.type.Z) =>
-            UnderLets.Base (- $v0)%expr)
-        else UnderLets.Base (- x)%expr
-    | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-      (_ @ _)%expr_pat _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _)
-      _ =>
-        if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
-        then
-         UnderLets.UnderLet x
-           (fun v : var (type.base base.type.Z) => UnderLets.Base (- $v)%expr)
-        else UnderLets.Base (- x)%expr
-    | _ =>
-        if negb (SubstVarLike.is_var_fst_snd_pair_opp x)
-        then
-         UnderLets.UnderLet x
-           (fun v : var (type.base base.type.Z) => UnderLets.Base (- $v)%expr)
-        else UnderLets.Base (- x)%expr
+    | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+      (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat _ |
+      @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default0 tt
     end
 | ident.Z_div =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (x / x0)%expr in
     match x0 with
     | #(idc)%expr_pat =>
         match
@@ -4102,13 +2969,14 @@ match idc in (ident t) return (Compile.value' true t) with
             else
              if args =? 2 ^ Z.log2 args
              then UnderLets.Base (x >> ##(Z.log2 args))%expr
-             else UnderLets.Base (x / x0)%expr
-        | None => UnderLets.Base (x / x0)%expr
+             else default
+        | None => default
         end
-    | _ => UnderLets.Base (x / x0)%expr
+    | _ => default
     end
 | ident.Z_modulo =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (x mod x0)%expr in
     match x0 with
     | #(idc)%expr_pat =>
         match
@@ -4129,40 +2997,76 @@ match idc in (ident t) return (Compile.value' true t) with
             else
              if args =? 2 ^ Z.log2 args
              then UnderLets.Base (x &' ##((args - 1)%Z))%expr
-             else UnderLets.Base (x mod x0)%expr
-        | None => UnderLets.Base (x mod x0)%expr
+             else default
+        | None => default
         end
-    | _ => UnderLets.Base (x mod x0)%expr
+    | _ => default
     end
 | ident.Z_log2 =>
     fun x : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_log2)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_log2)%expr @ x)%expr_pat in
+    default
 | ident.Z_log2_up =>
     fun x : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_log2_up)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_log2_up)%expr @ x)%expr_pat in
+    default
 | ident.Z_eqb =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_eqb)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_eqb)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Z_leb =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_leb)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_leb)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Z_geb =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_geb)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_geb)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Z_of_nat =>
     fun x : defaults.expr (type.base base.type.nat) =>
-    UnderLets.Base (#(ident.Z_of_nat)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_of_nat)%expr @ x)%expr_pat in
+    default
 | ident.Z_to_nat =>
     fun x : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_to_nat)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_to_nat)%expr @ x)%expr_pat in
+    default
 | ident.Z_shiftr =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (x >> x0)%expr
+    llet default := UnderLets.Base (x >> x0)%expr in
+    default
 | ident.Z_shiftl =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (x << x0)%expr
+    llet default := UnderLets.Base (x << x0)%expr in
+    default
 | ident.Z_land =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base (x &' x0)%expr in
+    llet default0 := fun 'tt =>
+                     match x with
+                     | #(idc)%expr_pat =>
+                         match
+                           match idc with
+                           | @ident.Literal t0 v =>
+                               match
+                                 t0 as t1
+                                 return (base.base_interp t1 -> option Z)
+                               with
+                               | base.type.unit => fun _ : unit => None
+                               | base.type.Z => fun v0 : Z => Some v0
+                               | base.type.bool => fun _ : bool => None
+                               | base.type.nat => fun _ : nat => None
+                               end v
+                           | _ => None
+                           end
+                         with
+                         | Some args =>
+                             if args =? 0
+                             then UnderLets.Base ##(0)%expr
+                             else default
+                         | None => default
+                         end
+                     | _ => default
+                     end in
     match x0 with
     | #(idc)%expr_pat =>
         match
@@ -4178,121 +3082,38 @@ match idc in (ident t) return (Compile.value' true t) with
           end
         with
         | Some args =>
-            if args =? 0
-            then UnderLets.Base ##(0)%expr
-            else
-             match x with
-             | #(idc0)%expr_pat =>
-                 match
-                   match idc0 with
-                   | @ident.Literal t1 v =>
-                       match
-                         t1 as t2 return (base.base_interp t2 -> option Z)
-                       with
-                       | base.type.unit => fun _ : unit => None
-                       | base.type.Z => fun v0 : Z => Some v0
-                       | base.type.bool => fun _ : bool => None
-                       | base.type.nat => fun _ : nat => None
-                       end v
-                   | _ => None
-                   end
-                 with
-                 | Some args0 =>
-                     if args0 =? 0
-                     then UnderLets.Base ##(0)%expr
-                     else UnderLets.Base (x &' x0)%expr
-                 | None => UnderLets.Base (x &' x0)%expr
-                 end
-             | _ => UnderLets.Base (x &' x0)%expr
-             end
-        | None =>
-            match x with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args =? 0
-                    then UnderLets.Base ##(0)%expr
-                    else UnderLets.Base (x &' x0)%expr
-                | None => UnderLets.Base (x &' x0)%expr
-                end
-            | _ => UnderLets.Base (x &' x0)%expr
-            end
-        end
-    | ($_)%expr =>
-        match x with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else UnderLets.Base (x &' x0)%expr
-            | None => UnderLets.Base (x &' x0)%expr
-            end
-        | _ => UnderLets.Base (x &' x0)%expr
-        end
-    | _ =>
-        match x with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args =? 0
-                then UnderLets.Base ##(0)%expr
-                else UnderLets.Base (x &' x0)%expr
-            | None => UnderLets.Base (x &' x0)%expr
-            end
-        | _ => UnderLets.Base (x &' x0)%expr
+            if args =? 0 then UnderLets.Base ##(0)%expr else default
+        | None => default0 tt
         end
+    | _ => default0 tt
     end
 | ident.Z_lor =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (x || x0)%expr
+    llet default := UnderLets.Base (x || x0)%expr in
+    default
 | ident.Z_bneg =>
     fun x : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_bneg)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_bneg)%expr @ x)%expr_pat in
+    default
 | ident.Z_lnot_modulo =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_lnot_modulo)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.Z_lnot_modulo)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Z_mul_split =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base
+                      (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat in
+    llet default0 := fun 'tt =>
+                     UnderLets.UnderLet
+                       (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
+                       (fun
+                          v : var
+                                (type.base (base.type.Z * base.type.Z)%etype)
+                        =>
+                        UnderLets.Base
+                          (#(ident.fst)%expr @ ($v)%expr,
+                          #(ident.snd)%expr @ ($v)%expr)%expr_pat) in
     match x with
     | #(idc)%expr_pat =>
         match
@@ -4308,6 +3129,248 @@ match idc in (ident t) return (Compile.value' true t) with
           end
         with
         | Some _ =>
+            llet default1 := fun 'tt =>
+                             llet default1 := fun 'tt =>
+                                              llet default1 := fun 'tt =>
+                                                               llet default1 := 
+                                                               fun 'tt =>
+                                                               llet default1 := 
+                                                               fun 'tt =>
+                                                               match x1 with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    if
+                                                                    args0 =?
+                                                                    -1
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (
+                                                                    (- x0)%expr,
+                                                                    ##
+                                                                    (0)%expr)%expr_pat
+                                                                    else
+                                                                    default
+                                                                   | None =>
+                                                                    default
+                                                                   end
+                                                               | _ => default
+                                                               end in
+                                                               match x0 with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    if
+                                                                    args0 =?
+                                                                    -1
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (
+                                                                    (- x1)%expr,
+                                                                    ##
+                                                                    (0)%expr)%expr_pat
+                                                                    else
+                                                                    default
+                                                                   | None =>
+                                                                    default1
+                                                                    tt
+                                                                   end
+                                                               | _ =>
+                                                                   default1
+                                                                    tt
+                                                               end in
+                                                               match x1 with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    if
+                                                                    args0 =?
+                                                                    1
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (x0,
+                                                                    ##
+                                                                    (0)%expr)%expr_pat
+                                                                    else
+                                                                    default
+                                                                   | None =>
+                                                                    default1
+                                                                    tt
+                                                                   end
+                                                               | _ =>
+                                                                   default1
+                                                                    tt
+                                                               end in
+                                              match x0 with
+                                              | #(idc0)%expr_pat =>
+                                                  match
+                                                    match idc0 with
+                                                    | @ident.Literal t1 v =>
+                                                        match
+                                                          t1 as t2
+                                                          return
+                                                            (base.base_interp
+                                                               t2 -> 
+                                                             option Z)
+                                                        with
+                                                        | base.type.unit =>
+                                                            fun _ : unit =>
+                                                            None
+                                                        | base.type.Z =>
+                                                            fun v0 : Z =>
+                                                            Some v0
+                                                        | base.type.bool =>
+                                                            fun _ : bool =>
+                                                            None
+                                                        | base.type.nat =>
+                                                            fun _ : nat =>
+                                                            None
+                                                        end v
+                                                    | _ => None
+                                                    end
+                                                  with
+                                                  | Some args0 =>
+                                                      if args0 =? 1
+                                                      then
+                                                       UnderLets.Base
+                                                         (x1, ##(0)%expr)%expr_pat
+                                                      else default
+                                                  | None => default1 tt
+                                                  end
+                                              | _ => default1 tt
+                                              end in
+                             match x1 with
+                             | #(idc0)%expr_pat =>
+                                 match
+                                   match idc0 with
+                                   | @ident.Literal t1 v =>
+                                       match
+                                         t1 as t2
+                                         return
+                                           (base.base_interp t2 -> option Z)
+                                       with
+                                       | base.type.unit =>
+                                           fun _ : unit => None
+                                       | base.type.Z => fun v0 : Z => Some v0
+                                       | base.type.bool =>
+                                           fun _ : bool => None
+                                       | base.type.nat => fun _ : nat => None
+                                       end v
+                                   | _ => None
+                                   end
+                                 with
+                                 | Some args0 =>
+                                     if args0 =? 0
+                                     then
+                                      UnderLets.Base
+                                        (##(0)%expr, ##(0)%expr)%expr_pat
+                                     else default
+                                 | None => default1 tt
+                                 end
+                             | _ => default1 tt
+                             end in
             match x0 with
             | #(idc0)%expr_pat =>
                 match
@@ -4327,1058 +3390,305 @@ match idc in (ident t) return (Compile.value' true t) with
                 | Some args0 =>
                     if args0 =? 0
                     then UnderLets.Base (##(0)%expr, ##(0)%expr)%expr_pat
-                    else
-                     match x1 with
-                     | #(idc1)%expr_pat =>
-                         match
-                           match idc1 with
-                           | @ident.Literal t2 v =>
-                               match
-                                 t2 as t3
-                                 return (base.base_interp t3 -> option Z)
-                               with
-                               | base.type.unit => fun _ : unit => None
-                               | base.type.Z => fun v0 : Z => Some v0
-                               | base.type.bool => fun _ : bool => None
-                               | base.type.nat => fun _ : nat => None
-                               end v
-                           | _ => None
-                           end
-                         with
-                         | Some args1 =>
-                             if args1 =? 0
-                             then
-                              UnderLets.Base
-                                (##(0)%expr, ##(0)%expr)%expr_pat
-                             else
-                              if args0 =? 1
-                              then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                              else
-                               if args1 =? 1
-                               then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                               else
-                                if args0 =? -1
-                                then
-                                 UnderLets.Base
-                                   ((- x1)%expr, ##(0)%expr)%expr_pat
-                                else
-                                 if args1 =? -1
-                                 then
-                                  UnderLets.Base
-                                    ((- x0)%expr, ##(0)%expr)%expr_pat
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         | None =>
-                             if args0 =? 1
-                             then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                             else
-                              if args0 =? -1
-                              then
-                               UnderLets.Base
-                                 ((- x1)%expr, ##(0)%expr)%expr_pat
-                              else
-                               UnderLets.UnderLet
-                                 (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                                 (fun
-                                    v : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                  =>
-                                  UnderLets.Base
-                                    (#(ident.fst)%expr @ ($v)%expr,
-                                    #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                     | ($_)%expr =>
-                         if args0 =? 1
-                         then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                         else
-                          if args0 =? -1
-                          then
-                           UnderLets.Base ((- x1)%expr, ##(0)%expr)%expr_pat
-                          else
-                           UnderLets.UnderLet
-                             (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                     | _ =>
-                         if args0 =? 1
-                         then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                         else
-                          if args0 =? -1
-                          then
-                           UnderLets.Base ((- x1)%expr, ##(0)%expr)%expr_pat
-                          else
-                           UnderLets.UnderLet
-                             (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                             (fun
-                                v : var
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v)%expr,
-                                #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                     end
-                | None =>
-                    match x1 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            if args0 =? 0
-                            then
-                             UnderLets.Base (##(0)%expr, ##(0)%expr)%expr_pat
-                            else
-                             if args0 =? 1
-                             then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                             else
-                              if args0 =? -1
-                              then
-                               UnderLets.Base
-                                 ((- x0)%expr, ##(0)%expr)%expr_pat
-                              else
-                               UnderLets.UnderLet
-                                 (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                                 (fun
-                                    v : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                  =>
-                                  UnderLets.Base
-                                    (#(ident.fst)%expr @ ($v)%expr,
-                                    #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                end
-            | ($_)%expr =>
-                match x1 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if args0 =? 0
-                        then UnderLets.Base (##(0)%expr, ##(0)%expr)%expr_pat
-                        else
-                         if args0 =? 1
-                         then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                         else
-                          if args0 =? -1
-                          then
-                           UnderLets.Base ((- x0)%expr, ##(0)%expr)%expr_pat
-                          else
-                           UnderLets.UnderLet
-                             (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | _ =>
-                match x1 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if args0 =? 0
-                        then UnderLets.Base (##(0)%expr, ##(0)%expr)%expr_pat
-                        else
-                         if args0 =? 1
-                         then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                         else
-                          if args0 =? -1
-                          then
-                           UnderLets.Base ((- x0)%expr, ##(0)%expr)%expr_pat
-                          else
-                           UnderLets.UnderLet
-                             (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                             (fun
-                                v : var
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v)%expr,
-                                #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+                    else default
+                | None => default1 tt
                 end
+            | _ => default1 tt
             end
-        | None =>
-            UnderLets.UnderLet
-              (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+        | None => default0 tt
         end
-    | ($_)%expr =>
-        UnderLets.UnderLet (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-          (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-           UnderLets.Base
-             (#(ident.fst)%expr @ ($v0)%expr, #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-    | _ =>
-        UnderLets.UnderLet (#(ident.Z_mul_split)%expr @ x @ x0 @ x1)%expr_pat
-          (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-           UnderLets.Base
-             (#(ident.fst)%expr @ ($v)%expr, #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+    | _ => default0 tt
     end
 | ident.Z_add_get_carry =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
-    match x0 with
-    | #(idc)%expr_pat =>
-        match
-          match idc with
-          | @ident.Literal t0 v =>
-              match t0 as t1 return (base.base_interp t1 -> option Z) with
-              | base.type.unit => fun _ : unit => None
-              | base.type.Z => fun v0 : Z => Some v0
-              | base.type.bool => fun _ : bool => None
-              | base.type.nat => fun _ : nat => None
-              end v
-          | _ => None
-          end
-        with
-        | Some args =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args0 =>
-                    if args <? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                        ##((- args)%Z)%expr)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                    else
-                     if args0 <? 0
-                     then
-                      UnderLets.UnderLet
-                        (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                         ##((- args0)%Z)%expr)%expr_pat
-                        (fun
-                           v : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                         =>
-                         UnderLets.Base
-                           (#(ident.fst)%expr @ ($v)%expr,
-                           (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                     else
-                      if args =? 0
-                      then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                      else
-                       if args0 =? 0
-                       then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                       else
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | None =>
-                    if args <? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                        ##((- args)%Z)%expr)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                    else
-                     if args =? 0
-                     then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                     else
-                      UnderLets.UnderLet
-                        (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                        (fun
-                           v : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                         =>
-                         UnderLets.Base
-                           (#(ident.fst)%expr @ ($v)%expr,
-                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | ($_)%expr =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun
-                      v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v0)%expr,
-                      (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v0)%expr,
-                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x2 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr
-                              (type.base (base.type.Z * base.type.Z)%etype)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr
-                                (type.base (base.type.Z * base.type.Z)%etype)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' =>
-                               UnderLets.UnderLet
-                                 (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                                  x' v)%expr_pat
-                                 (fun
-                                    v0 : var
-                                           (type.base
-                                              (base.type.Z * base.type.Z)%etype)
-                                  =>
-                                  UnderLets.Base
-                                    (#(ident.fst)%expr @ ($v0)%expr,
-                                    (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                           | None =>
-                               UnderLets.Base
-                                 (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base
-                          (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    end (Compile.reflect x2)
-                | None =>
-                    if args <? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                        ##((- args)%Z)%expr)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                    else
-                     if args =? 0
-                     then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                     else
-                      UnderLets.UnderLet
-                        (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                        (fun
-                           v : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                         =>
-                         UnderLets.Base
-                           (#(ident.fst)%expr @ ($v)%expr,
-                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun
-                      v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v0)%expr,
-                      (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v0)%expr,
-                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _
-              s _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | _ =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x1 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | None =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args <? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                        ##((- args)%Z)%expr)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                    else
-                     if args =? 0
-                     then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                     else
-                      UnderLets.UnderLet
-                        (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                        (fun
-                           v : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                         =>
-                         UnderLets.Base
-                           (#(ident.fst)%expr @ ($v)%expr,
-                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | ($_)%expr =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s _ #(idc0)%expr_pat x2 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr
-                              (type.base (base.type.Z * base.type.Z)%etype)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr
-                                (type.base (base.type.Z * base.type.Z)%etype)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' =>
-                               UnderLets.UnderLet
-                                 (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                                  x' v)%expr_pat
-                                 (fun
-                                    v0 : var
-                                           (type.base
-                                              (base.type.Z * base.type.Z)%etype)
-                                  =>
-                                  UnderLets.Base
-                                    (#(ident.fst)%expr @ ($v0)%expr,
-                                    (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                           | None =>
-                               UnderLets.Base
-                                 (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base
-                          (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    end (Compile.reflect x2)
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _
-              s _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-              (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        end
-    | ($_)%expr =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun
-                      v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v0)%expr,
-                      (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v0)%expr,
-                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v0 : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t1 : base.type => defaults.expr (type.base t1)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v0)%expr_pat
-                             (fun
-                                v1 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v1)%expr,
-                                (- (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x2)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-          (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        end
-    | @expr.Abs _ _ _ _ _ _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x2 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v)%expr_pat
-                             (fun
-                                v0 : var
+    llet default := UnderLets.Base
+                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat in
+    llet default0 := fun 'tt =>
+                     llet default0 := fun 'tt =>
+                                      llet default0 := fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       llet default0 := 
+                                                       fun 'tt =>
+                                                       UnderLets.UnderLet
+                                                         (#(ident.Z_add_get_carry)%expr @
+                                                          x @ x0 @ x1)%expr_pat
+                                                         (fun
+                                                            v : var
+                                                                  (type.base
+                                                                    (base.type.Z *
+                                                                    base.type.Z)%etype)
+                                                          =>
+                                                          UnderLets.Base
+                                                            (#(ident.fst)%expr @
+                                                             ($v)%expr,
+                                                            #(ident.snd)%expr @
+                                                            ($v)%expr)%expr_pat) in
+                                                       match x1 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args =? 0
+                                                               then
+                                                                UnderLets.Base
+                                                                  (x0,
+                                                                  ##(0)%expr)%expr_pat
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x0 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args =? 0
+                                                               then
+                                                                UnderLets.Base
+                                                                  (x1,
+                                                                  ##(0)%expr)%expr_pat
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                                       match x1 with
+                                                       | #(idc)%expr_pat =>
+                                                           match
+                                                             match idc with
+                                                             | @ident.Literal
+                                                               t0 v =>
+                                                                 match
+                                                                   t0 as t1
+                                                                   return
+                                                                    (base.base_interp
+                                                                    t1 ->
+                                                                    option Z)
+                                                                 with
+                                                                 | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                 | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                 | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                 | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                 end v
+                                                             | _ => None
+                                                             end
+                                                           with
+                                                           | Some args =>
+                                                               if args <? 0
+                                                               then
+                                                                UnderLets.UnderLet
+                                                                  (#(ident.Z_sub_get_borrow)%expr @
+                                                                   x @ x0 @
+                                                                   ##
+                                                                   ((- args)%Z)%expr)%expr_pat
+                                                                  (fun
+                                                                    v : 
+                                                                    var
+                                                                    (type.base
+                                                                    (base.type.Z *
+                                                                    base.type.Z)%etype)
+                                                                   =>
+                                                                   UnderLets.Base
+                                                                    (
+                                                                    #
+                                                                    (ident.fst)%expr @
+                                                                    ($v)%expr,
+                                                                    (-
+                                                                    (#
+                                                                    (ident.snd)%expr @
+                                                                    $v)%expr_pat)%expr)%expr_pat)
+                                                               else default
+                                                           | None =>
+                                                               default0 tt
+                                                           end
+                                                       | _ => default0 tt
+                                                       end in
+                                      match x0 with
+                                      | #(idc)%expr_pat =>
+                                          match
+                                            match idc with
+                                            | @ident.Literal t0 v =>
+                                                match
+                                                  t0 as t1
+                                                  return
+                                                    (base.base_interp t1 ->
+                                                     option Z)
+                                                with
+                                                | base.type.unit =>
+                                                    fun _ : unit => None
+                                                | base.type.Z =>
+                                                    fun v0 : Z => Some v0
+                                                | base.type.bool =>
+                                                    fun _ : bool => None
+                                                | base.type.nat =>
+                                                    fun _ : nat => None
+                                                end v
+                                            | _ => None
+                                            end
+                                          with
+                                          | Some args =>
+                                              if args <? 0
+                                              then
+                                               UnderLets.UnderLet
+                                                 (#(ident.Z_sub_get_borrow)%expr @
+                                                  x @ x1 @
+                                                  ##((- args)%Z)%expr)%expr_pat
+                                                 (fun
+                                                    v : var
+                                                          (type.base
+                                                             (base.type.Z *
+                                                              base.type.Z)%etype)
+                                                  =>
+                                                  UnderLets.Base
+                                                    (#(ident.fst)%expr @
+                                                     ($v)%expr,
+                                                    (-
+                                                     (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
+                                              else default
+                                          | None => default0 tt
+                                          end
+                                      | _ => default0 tt
+                                      end in
+                     match x1 with
+                     | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
+                         match
+                           match idc with
+                           | ident.Z_opp => Some tt
+                           | _ => None
+                           end
+                         with
+                         | Some _ =>
+                             match
+                               s as t2
+                               return
+                                 (Compile.value' false t2 ->
+                                  UnderLets.UnderLets base.type ident var
+                                    (defaults.expr
                                        (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x2)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        end
+                                          (base.type.Z * base.type.Z)%etype)))
+                             with
+                             | type.base t2 =>
+                                 fun v : defaults.expr (type.base t2) =>
+                                 base.try_make_transport_cps
+                                   (fun t0 : base.type =>
+                                    defaults.expr (type.base t0)) t2
+                                   base.type.Z
+                                   (UnderLets.UnderLets base.type ident var
+                                      (defaults.expr
+                                         (type.base
+                                            (base.type.Z * base.type.Z)%etype)))
+                                   (fun
+                                      a : option
+                                            (defaults.expr (type.base t2) ->
+                                             defaults.expr
+                                               (type.base base.type.Z)) =>
+                                    match a with
+                                    | Some x' =>
+                                        UnderLets.UnderLet
+                                          (#(ident.Z_sub_get_borrow)%expr @ x @
+                                           x0 @ x' v)%expr_pat
+                                          (fun
+                                             v0 : var
+                                                    (type.base
+                                                       (base.type.Z *
+                                                        base.type.Z)%etype)
+                                           =>
+                                           UnderLets.Base
+                                             (#(ident.fst)%expr @ ($v0)%expr,
+                                             (-
+                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
+                                    | None => default
+                                    end)
+                             | (s0 -> d0)%ptype =>
+                                 fun
+                                   _ : Compile.value' false s0 ->
+                                       Compile.value' true d0 => default
+                             end (Compile.reflect x2)
+                         | None => default
+                         end
+                     | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+                       (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
+                       (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
+                       (@expr.LetIn _ _ _ _ _ _ _) _ => default
+                     | _ => default0 tt
+                     end in
+    match x0 with
     | @expr.App _ _ _ s _ #(idc)%expr_pat x2 =>
         match match idc with
               | ident.Z_opp => Some tt
@@ -5416,867 +3726,28 @@ match idc in (ident t) return (Compile.value' true t) with
                           UnderLets.Base
                             (#(ident.fst)%expr @ ($v0)%expr,
                             (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                   | None =>
-                       UnderLets.Base
-                         (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
+                   | None => default
                    end)
             | (s0 -> d0)%ptype =>
                 fun _ : Compile.value' false s0 -> Compile.value' true d0 =>
-                UnderLets.Base
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
+                default
             end (Compile.reflect x2)
-        | None =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    if args <? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                        ##((- args)%Z)%expr)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                    else
-                     if args =? 0
-                     then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                     else
-                      UnderLets.UnderLet
-                        (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                        (fun
-                           v : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                         =>
-                         UnderLets.Base
-                           (#(ident.fst)%expr @ ($v)%expr,
-                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | ($_)%expr =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x3 =>
-                match
-                  match idc0 with
-                  | ident.Z_opp => Some tt
-                  | _ => None
-                  end
-                with
-                | Some _ =>
-                    match
-                      s0 as t2
-                      return
-                        (Compile.value' false t2 ->
-                         UnderLets.UnderLets base.type ident var
-                           (defaults.expr
-                              (type.base (base.type.Z * base.type.Z)%etype)))
-                    with
-                    | type.base t2 =>
-                        fun v : defaults.expr (type.base t2) =>
-                        base.try_make_transport_cps
-                          (fun t1 : base.type => defaults.expr (type.base t1))
-                          t2 base.type.Z
-                          (UnderLets.UnderLets base.type ident var
-                             (defaults.expr
-                                (type.base (base.type.Z * base.type.Z)%etype)))
-                          (fun
-                             a : option
-                                   (defaults.expr (type.base t2) ->
-                                    defaults.expr (type.base base.type.Z)) =>
-                           match a with
-                           | Some x' =>
-                               UnderLets.UnderLet
-                                 (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                                  x' v)%expr_pat
-                                 (fun
-                                    v0 : var
-                                           (type.base
-                                              (base.type.Z * base.type.Z)%etype)
-                                  =>
-                                  UnderLets.Base
-                                    (#(ident.fst)%expr @ ($v0)%expr,
-                                    (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                           | None =>
-                               UnderLets.Base
-                                 (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                           end)
-                    | (s1 -> d1)%ptype =>
-                        fun
-                          _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base
-                          (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    end (Compile.reflect x3)
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _
-              _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-              (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        end
-    | @expr.App _ _ _ s _ ($_)%expr _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun
-                      v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v0)%expr,
-                      (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v0)%expr,
-                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x3 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v0 : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t1 : base.type => defaults.expr (type.base t1)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v0)%expr_pat
-                             (fun
-                                v1 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v1)%expr,
-                                (- (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x3)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        end
-    | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s1 _ #(idc)%expr_pat x3 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s1 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s2 -> d2)%ptype =>
-                    fun _ : Compile.value' false s2 -> Compile.value' true d2
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x3)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s1
-          _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        end
-    | @expr.App _ _ _ s _ (_ @ _)%expr_pat _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s1 _ #(idc)%expr_pat x4 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s1 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s2 -> d2)%ptype =>
-                    fun _ : Compile.value' false s2 -> Compile.value' true d2
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x4)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s1
-          _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        end
-    | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ #(idc)%expr_pat x4 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s0 as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s1 -> d1)%ptype =>
-                    fun _ : Compile.value' false s1 -> Compile.value' true d1
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x4)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0
-          _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        end
-    | @expr.LetIn _ _ _ _ _ _ _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                if args <? 0
-                then
-                 UnderLets.UnderLet
-                   (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @
-                    ##((- args)%Z)%expr)%expr_pat
-                   (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                    =>
-                    UnderLets.Base
-                      (#(ident.fst)%expr @ ($v)%expr,
-                      (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                else
-                 if args =? 0
-                 then UnderLets.Base (x0, ##(0)%expr)%expr_pat
-                 else
-                  UnderLets.UnderLet
-                    (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                    (fun
-                       v : var (type.base (base.type.Z * base.type.Z)%etype)
-                     =>
-                     UnderLets.Base
-                       (#(ident.fst)%expr @ ($v)%expr,
-                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s _ #(idc)%expr_pat x3 =>
-            match
-              match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end
-            with
-            | Some _ =>
-                match
-                  s as t2
-                  return
-                    (Compile.value' false t2 ->
-                     UnderLets.UnderLets base.type ident var
-                       (defaults.expr
-                          (type.base (base.type.Z * base.type.Z)%etype)))
-                with
-                | type.base t2 =>
-                    fun v : defaults.expr (type.base t2) =>
-                    base.try_make_transport_cps
-                      (fun t0 : base.type => defaults.expr (type.base t0)) t2
-                      base.type.Z
-                      (UnderLets.UnderLets base.type ident var
-                         (defaults.expr
-                            (type.base (base.type.Z * base.type.Z)%etype)))
-                      (fun
-                         a : option
-                               (defaults.expr (type.base t2) ->
-                                defaults.expr (type.base base.type.Z)) =>
-                       match a with
-                       | Some x' =>
-                           UnderLets.UnderLet
-                             (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x' v)%expr_pat
-                             (fun
-                                v0 : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                              =>
-                              UnderLets.Base
-                                (#(ident.fst)%expr @ ($v0)%expr,
-                                (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                       | None =>
-                           UnderLets.Base
-                             (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                       end)
-                | (s0 -> d0)%ptype =>
-                    fun _ : Compile.value' false s0 -> Compile.value' true d0
-                    =>
-                    UnderLets.Base
-                      (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                end (Compile.reflect x3)
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | @expr.App _ _ _ s _ ($_)%expr _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-          (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-          (@expr.LetIn _ _ _ _ _ _ _) _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_get_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+        | None => default
         end
+    | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+      (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat _ |
+      @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default0 tt
     end
 | ident.Z_add_with_carry =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
+    llet default := UnderLets.Base
+                      (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat in
+    llet default0 := fun 'tt =>
+                     UnderLets.UnderLet
+                       (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat
+                       (fun v : var (type.base base.type.Z) =>
+                        UnderLets.Base ($v)%expr) in
     match x with
     | #(idc)%expr_pat =>
         match
@@ -6292,340 +3763,55 @@ match idc in (ident t) return (Compile.value' true t) with
           end
         with
         | Some args =>
-            if args =? 0
-            then UnderLets.Base (x0 + x1)%expr
-            else
-             UnderLets.UnderLet
-               (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat
-               (fun v : var (type.base base.type.Z) =>
-                UnderLets.Base ($v)%expr)
-        | None =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat
-              (fun v : var (type.base base.type.Z) =>
-               UnderLets.Base ($v)%expr)
+            if args =? 0 then UnderLets.Base (x0 + x1)%expr else default
+        | None => default0 tt
         end
-    | ($_)%expr =>
-        UnderLets.UnderLet
-          (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat
-          (fun v0 : var (type.base base.type.Z) => UnderLets.Base ($v0)%expr)
-    | _ =>
-        UnderLets.UnderLet
-          (#(ident.Z_add_with_carry)%expr @ x @ x0 @ x1)%expr_pat
-          (fun v : var (type.base base.type.Z) => UnderLets.Base ($v)%expr)
+    | _ => default0 tt
     end
 | ident.Z_add_with_get_carry =>
     fun x x0 x1 x2 : defaults.expr (type.base base.type.Z) =>
-    match x0 with
-    | #(idc)%expr_pat =>
-        match
-          match idc with
-          | @ident.Literal t0 v =>
-              match t0 as t1 return (base.base_interp t1 -> option Z) with
-              | base.type.unit => fun _ : unit => None
-              | base.type.Z => fun v0 : Z => Some v0
-              | base.type.bool => fun _ : bool => None
-              | base.type.nat => fun _ : nat => None
-              end v
-          | _ => None
-          end
-        with
-        | Some args =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args0 =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args1 =>
-                            if
-                             (args0 <=? 0) && (args <=? 0) &&
-                             (args0 + args <? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                ##((- args)%Z)%expr @ x2 @
-                                ##((- args0)%Z)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                            else
-                             if
-                              (args1 <=? 0) && (args <=? 0) &&
-                              (args1 + args <? 0)
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                 ##((- args)%Z)%expr @ x1 @
-                                 ##((- args1)%Z)%expr)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                             else
-                              match x with
-                              | #(idc2)%expr_pat =>
-                                  match
-                                    match idc2 with
-                                    | @ident.Literal t3 v =>
-                                        match
-                                          t3 as t4
-                                          return
-                                            (base.base_interp t4 -> option Z)
-                                        with
-                                        | base.type.unit =>
-                                            fun _ : unit => None
-                                        | base.type.Z =>
-                                            fun v0 : Z => Some v0
-                                        | base.type.bool =>
-                                            fun _ : bool => None
-                                        | base.type.nat =>
-                                            fun _ : nat => None
-                                        end v
-                                    | _ => None
-                                    end
-                                  with
-                                  | Some _ =>
-                                      if (args =? 0) && (args0 =? 0)
-                                      then
-                                       UnderLets.Base
-                                         (x2, ##(0)%expr)%expr_pat
-                                      else
-                                       if (args =? 0) && (args1 =? 0)
-                                       then
-                                        UnderLets.Base
-                                          (x1, ##(0)%expr)%expr_pat
-                                       else
-                                        if args =? 0
-                                        then
-                                         UnderLets.UnderLet
-                                           (#(ident.Z_add_get_carry)%expr @ x @
-                                            x1 @ x2)%expr_pat
-                                           (fun
-                                              v : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                            =>
-                                            UnderLets.Base
-                                              (#(ident.fst)%expr @ ($v)%expr,
-                                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                        else
-                                         if (args0 =? 0) && (args1 =? 0)
-                                         then
-                                          UnderLets.UnderLet
-                                            (#(ident.Z_add_with_get_carry)%expr @
-                                             x @ x0 @ ##(args0)%expr @
-                                             ##(args1)%expr)%expr_pat
-                                            (fun
-                                               v : var
-                                                     (type.base
-                                                        (base.type.Z *
-                                                         base.type.Z)%etype)
-                                             =>
-                                             UnderLets.Base
-                                               (#(ident.fst)%expr @ ($v)%expr,
-                                               ##(0)%expr)%expr_pat)
-                                         else
-                                          UnderLets.UnderLet
-                                            (#(ident.Z_add_with_get_carry)%expr @
-                                             x @ x0 @ x1 @ x2)%expr_pat
-                                            (fun
-                                               v : var
-                                                     (type.base
-                                                        (base.type.Z *
-                                                         base.type.Z)%etype)
-                                             =>
-                                             UnderLets.Base
-                                               (#(ident.fst)%expr @ ($v)%expr,
-                                               #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  | None =>
-                                      if args =? 0
-                                      then
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_get_carry)%expr @ x @
-                                          x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                      else
-                                       if (args0 =? 0) && (args1 =? 0)
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ ##(args0)%expr @
-                                           ##(args1)%expr)%expr_pat
-                                          (fun
-                                             v : var
-                                                   (type.base
-                                                      (base.type.Z *
-                                                       base.type.Z)%etype) =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v)%expr,
-                                             ##(0)%expr)%expr_pat)
-                                       else
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                          (fun
-                                             v : var
-                                                   (type.base
-                                                      (base.type.Z *
-                                                       base.type.Z)%etype) =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v)%expr,
-                                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  end
-                              | ($_)%expr =>
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                  else
-                                   if (args0 =? 0) && (args1 =? 0)
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ ##(args0)%expr @ ##(args1)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         ##(0)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                              | _ =>
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   if (args0 =? 0) && (args1 =? 0)
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ ##(args0)%expr @ ##(args1)%expr)%expr_pat
-                                      (fun
-                                         v : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v)%expr,
-                                         ##(0)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v)%expr,
-                                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                              end
-                        | None =>
-                            if
-                             (args0 <=? 0) && (args <=? 0) &&
-                             (args0 + args <? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                ##((- args)%Z)%expr @ x2 @
-                                ##((- args0)%Z)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                            else
-                             match x with
-                             | #(idc2)%expr_pat =>
+    llet default := UnderLets.Base
+                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat in
+    llet default0 := fun 'tt =>
+                     llet default0 := fun 'tt =>
+                                      UnderLets.UnderLet
+                                        (#(ident.Z_add_with_get_carry)%expr @
+                                         x @ x0 @ x1 @ x2)%expr_pat
+                                        (fun
+                                           v : var
+                                                 (type.base
+                                                    (base.type.Z *
+                                                     base.type.Z)%etype) =>
+                                         UnderLets.Base
+                                           (#(ident.fst)%expr @ ($v)%expr,
+                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat) in
+                     match x1 with
+                     | #(idc)%expr_pat =>
+                         match
+                           match idc with
+                           | @ident.Literal t0 v =>
+                               match
+                                 t0 as t1
+                                 return (base.base_interp t1 -> option Z)
+                               with
+                               | base.type.unit => fun _ : unit => None
+                               | base.type.Z => fun v0 : Z => Some v0
+                               | base.type.bool => fun _ : bool => None
+                               | base.type.nat => fun _ : nat => None
+                               end v
+                           | _ => None
+                           end
+                         with
+                         | Some args =>
+                             match x2 with
+                             | #(idc0)%expr_pat =>
                                  match
-                                   match idc2 with
-                                   | @ident.Literal t3 v =>
+                                   match idc0 with
+                                   | @ident.Literal t1 v =>
                                        match
-                                         t3 as t4
+                                         t1 as t2
                                          return
-                                           (base.base_interp t4 -> option Z)
+                                           (base.base_interp t2 -> option Z)
                                        with
                                        | base.type.unit =>
                                            fun _ : unit => None
@@ -6637,55 +3823,13 @@ match idc in (ident t) return (Compile.value' true t) with
                                    | _ => None
                                    end
                                  with
-                                 | Some _ =>
+                                 | Some args0 =>
                                      if (args =? 0) && (args0 =? 0)
                                      then
-                                      UnderLets.Base
-                                        (x2, ##(0)%expr)%expr_pat
-                                     else
-                                      if args =? 0
-                                      then
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_get_carry)%expr @ x @
-                                          x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                      else
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 | None =>
-                                     if args =? 0
-                                     then
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_get_carry)%expr @ x @
-                                         x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                     else
                                       UnderLets.UnderLet
                                         (#(ident.Z_add_with_get_carry)%expr @
-                                         x @ x0 @ x1 @ x2)%expr_pat
+                                         x @ x0 @ ##(args)%expr @
+                                         ##(args0)%expr)%expr_pat
                                         (fun
                                            v : var
                                                  (type.base
@@ -6693,2494 +3837,514 @@ match idc in (ident t) return (Compile.value' true t) with
                                                      base.type.Z)%etype) =>
                                          UnderLets.Base
                                            (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+                                           ##(0)%expr)%expr_pat)
+                                     else default
+                                 | None => default
                                  end
-                             | ($_)%expr =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | _ =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                        end
-                    | ($_)%expr =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t3 v0 =>
-                                   match
-                                     t3 as t4
-                                     return (base.base_interp t4 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v1 : Z => Some v1
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v0
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x2, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
+                             | _ => default
                              end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
+                         | None => default0 tt
                          end
-                    | @expr.App _ _ _ s _ #(idc1)%expr_pat x3 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args =? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_get_borrow)%expr @ x @
-                                           x1 @ x' v)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        match
-                                          s as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t4 : base.type =>
-                                               defaults.expr (type.base t4))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   if args <? 0
-                                                   then
-                                                    UnderLets.UnderLet
-                                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                                       x @
-                                                       ##((- args)%Z)%expr @
-                                                       x1 @ x'0 v0)%expr_pat
-                                                      (fun
-                                                         v1 : var
-                                                                (type.base
-                                                                   (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                       =>
-                                                       UnderLets.Base
-                                                         (#(ident.fst)%expr @
-                                                          ($v1)%expr,
-                                                         (-
-                                                          (#(ident.snd)%expr @
-                                                           $v1)%expr_pat)%expr)%expr_pat)
-                                                   else
-                                                    if
-                                                     (args0 <=? 0) &&
-                                                     (args <=? 0) &&
-                                                     (args0 + args <? 0)
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_sub_with_get_borrow)%expr @
-                                                        x @
-                                                        ##((- args)%Z)%expr @
-                                                        x2 @
-                                                        ##((- args0)%Z)%expr)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          (-
-                                                           (#(ident.snd)%expr @
-                                                            $v1)%expr_pat)%expr)%expr_pat)
-                                                    else
-                                                     match x with
-                                                     | #(idc2)%expr_pat =>
-                                                         match
-                                                           match idc2 with
-                                                           | @ident.Literal
-                                                             t5 v1 =>
-                                                               match
-                                                                 t5 as t6
-                                                                 return
-                                                                   (base.base_interp
-                                                                    t6 ->
-                                                                    option Z)
-                                                               with
-                                                               | base.type.unit =>
-                                                                   fun
-                                                                    _ : unit
-                                                                   => None
-                                                               | base.type.Z =>
-                                                                   fun v2 : Z
-                                                                   => 
-                                                                   Some v2
-                                                               | base.type.bool =>
-                                                                   fun
-                                                                    _ : bool
-                                                                   => None
-                                                               | base.type.nat =>
-                                                                   fun
-                                                                    _ : nat
-                                                                   => None
-                                                               end v1
-                                                           | _ => None
-                                                           end
-                                                         with
-                                                         | Some _ =>
-                                                             if
-                                                              (args =? 0) &&
-                                                              (args0 =? 0)
-                                                             then
-                                                              UnderLets.Base
-                                                                (x2,
-                                                                ##(0)%expr)%expr_pat
-                                                             else
-                                                              if args =? 0
-                                                              then
-                                                               UnderLets.UnderLet
-                                                                 (#(ident.Z_add_get_carry)%expr @
-                                                                  x @ x1 @ x2)%expr_pat
-                                                                 (fun
-                                                                    v1 : 
+                     | _ => default0 tt
+                     end in
+    match x0 with
+    | #(idc)%expr_pat =>
+        match
+          match idc with
+          | @ident.Literal t0 v =>
+              match t0 as t1 return (base.base_interp t1 -> option Z) with
+              | base.type.unit => fun _ : unit => None
+              | base.type.Z => fun v0 : Z => Some v0
+              | base.type.bool => fun _ : bool => None
+              | base.type.nat => fun _ : nat => None
+              end v
+          | _ => None
+          end
+        with
+        | Some args =>
+            llet default1 := fun 'tt =>
+                             llet default1 := fun 'tt =>
+                                              llet default1 := fun 'tt =>
+                                                               llet default1 := 
+                                                               fun 'tt =>
+                                                               llet default1 := 
+                                                               fun 'tt =>
+                                                               if args =? 0
+                                                               then
+                                                                UnderLets.UnderLet
+                                                                  (#(ident.Z_add_get_carry)%expr @
+                                                                   x @ x1 @
+                                                                   x2)%expr_pat
+                                                                  (fun
+                                                                    v : 
                                                                     var
                                                                     (type.base
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)
-                                                                  =>
-                                                                  UnderLets.Base
+                                                                   =>
+                                                                   UnderLets.Base
                                                                     (
                                                                     #
                                                                     (ident.fst)%expr @
-                                                                    ($v1)%expr,
+                                                                    ($v)%expr,
                                                                     #
                                                                     (ident.snd)%expr @
-                                                                    ($v1)%expr)%expr_pat)
-                                                              else
-                                                               UnderLets.UnderLet
-                                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                                  x @ x0 @ x1 @
-                                                                  x2)%expr_pat
-                                                                 (fun
-                                                                    v1 : 
+                                                                    ($v)%expr)%expr_pat)
+                                                               else default in
+                                                               match x with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    _ =>
+                                                                    llet default2 := 
+                                                                    fun 'tt
+                                                                    =>
+                                                                    match
+                                                                    x2
+                                                                    with
+                                                                    | #
+                                                                    (idc1)%expr_pat =>
+                                                                    match
+                                                                    match
+                                                                    idc1
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t2 v =>
+                                                                    match
+                                                                    t2 as t3
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t3 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                    with
+                                                                    | Some
+                                                                    args1 =>
+                                                                    if
+                                                                    (args =?
+                                                                    0) &&
+                                                                    (args1 =?
+                                                                    0)
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (x1,
+                                                                    ##
+                                                                    (0)%expr)%expr_pat
+                                                                    else
+                                                                    default
+                                                                    | None =>
+                                                                    default
+                                                                    end
+                                                                    | _ =>
+                                                                    default
+                                                                    end in
+                                                                    match
+                                                                    x1
+                                                                    with
+                                                                    | #
+                                                                    (idc1)%expr_pat =>
+                                                                    match
+                                                                    match
+                                                                    idc1
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t2 v =>
+                                                                    match
+                                                                    t2 as t3
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t3 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                    with
+                                                                    | Some
+                                                                    args1 =>
+                                                                    if
+                                                                    (args =?
+                                                                    0) &&
+                                                                    (args1 =?
+                                                                    0)
+                                                                    then
+                                                                    UnderLets.Base
+                                                                    (x2,
+                                                                    ##
+                                                                    (0)%expr)%expr_pat
+                                                                    else
+                                                                    default
+                                                                    | None =>
+                                                                    default2
+                                                                    tt
+                                                                    end
+                                                                    | _ =>
+                                                                    default2
+                                                                    tt
+                                                                    end
+                                                                   | None =>
+                                                                    default1
+                                                                    tt
+                                                                   end
+                                                               | _ =>
+                                                                   default1
+                                                                    tt
+                                                               end in
+                                                               match x2 with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
+                                                                    option Z)
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
+                                                                    _ : unit
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
+                                                                    _ : bool
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
+                                                                    _ : nat
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    if
+                                                                    (args0 <=?
+                                                                    0) &&
+                                                                    (args <=?
+                                                                    0) &&
+                                                                    (args0 +
+                                                                    args <? 0)
+                                                                    then
+                                                                    UnderLets.UnderLet
+                                                                    (#
+                                                                    (ident.Z_sub_with_get_borrow)%expr @
+                                                                    x @
+                                                                    ##
+                                                                    ((- args)%Z)%expr @
+                                                                    x1 @
+                                                                    ##
+                                                                    ((- args0)%Z)%expr)%expr_pat
+                                                                    (fun
+                                                                    v : 
                                                                     var
                                                                     (type.base
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)
-                                                                  =>
-                                                                  UnderLets.Base
+                                                                    =>
+                                                                    UnderLets.Base
                                                                     (
                                                                     #
                                                                     (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                    #
+                                                                    ($v)%expr,
+                                                                    (-
+                                                                    (#
                                                                     (ident.snd)%expr @
-                                                                    ($v1)%expr)%expr_pat)
-                                                         | None =>
-                                                             if args =? 0
-                                                             then
-                                                              UnderLets.UnderLet
-                                                                (#(ident.Z_add_get_carry)%expr @
-                                                                 x @ x1 @ x2)%expr_pat
-                                                                (fun
-                                                                   v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                 =>
-                                                                 UnderLets.Base
-                                                                   (#
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                   #(ident.snd)%expr @
-                                                                   ($v1)%expr)%expr_pat)
-                                                             else
-                                                              UnderLets.UnderLet
-                                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                                 x @ x0 @ x1 @
-                                                                 x2)%expr_pat
-                                                                (fun
-                                                                   v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                 =>
-                                                                 UnderLets.Base
-                                                                   (#
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                   #(ident.snd)%expr @
-                                                                   ($v1)%expr)%expr_pat)
-                                                         end
-                                                     | ($_)%expr =>
-                                                         if args =? 0
-                                                         then
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_get_carry)%expr @
-                                                             x @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v2 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v2)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v2)%expr)%expr_pat)
-                                                         else
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_with_get_carry)%expr @
-                                                             x @ x0 @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v2 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v2)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v2)%expr)%expr_pat)
-                                                     | _ =>
-                                                         if args =? 0
-                                                         then
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_get_carry)%expr @
-                                                             x @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v1 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v1)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v1)%expr)%expr_pat)
-                                                         else
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_with_get_carry)%expr @
-                                                             x @ x0 @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v1 : var
-                                                                    (type.base
+                                                                    $v)%expr_pat)%expr)%expr_pat)
+                                                                    else
+                                                                    default
+                                                                   | None =>
+                                                                    default1
+                                                                    tt
+                                                                   end
+                                                               | _ =>
+                                                                   default1
+                                                                    tt
+                                                               end in
+                                              match x1 with
+                                              | #(idc0)%expr_pat =>
+                                                  match
+                                                    match idc0 with
+                                                    | @ident.Literal t1 v =>
+                                                        match
+                                                          t1 as t2
+                                                          return
+                                                            (base.base_interp
+                                                               t2 -> 
+                                                             option Z)
+                                                        with
+                                                        | base.type.unit =>
+                                                            fun _ : unit =>
+                                                            None
+                                                        | base.type.Z =>
+                                                            fun v0 : Z =>
+                                                            Some v0
+                                                        | base.type.bool =>
+                                                            fun _ : bool =>
+                                                            None
+                                                        | base.type.nat =>
+                                                            fun _ : nat =>
+                                                            None
+                                                        end v
+                                                    | _ => None
+                                                    end
+                                                  with
+                                                  | Some args0 =>
+                                                      if
+                                                       (args0 <=? 0) &&
+                                                       (args <=? 0) &&
+                                                       (args0 + args <? 0)
+                                                      then
+                                                       UnderLets.UnderLet
+                                                         (#(ident.Z_sub_with_get_borrow)%expr @
+                                                          x @
+                                                          ##((- args)%Z)%expr @
+                                                          x2 @
+                                                          ##((- args0)%Z)%expr)%expr_pat
+                                                         (fun
+                                                            v : var
+                                                                  (type.base
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v1)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v1)%expr)%expr_pat)
-                                                     end
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (#(ident.Z_add_with_get_carry)%expr @
-                                                      x @ x0 @ x1 @ x2)%expr_pat
-                                               end)
-                                        | (s0 -> d0)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s0 ->
-                                                  Compile.value' true d0 =>
-                                            UnderLets.Base
-                                              (#(ident.Z_add_with_get_carry)%expr @
-                                               x @ x0 @ x1 @ x2)%expr_pat
-                                        end (Compile.reflect x3)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s0 -> d0)%ptype =>
-                                fun
-                                  _ : Compile.value' false s0 ->
-                                      Compile.value' true d0 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            if
-                             (args0 <=? 0) && (args <=? 0) &&
-                             (args0 + args <? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                ##((- args)%Z)%expr @ x2 @
-                                ##((- args0)%Z)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                            else
-                             match x with
-                             | #(idc2)%expr_pat =>
+                                                          =>
+                                                          UnderLets.Base
+                                                            (#(ident.fst)%expr @
+                                                             ($v)%expr,
+                                                            (-
+                                                             (#(ident.snd)%expr @
+                                                              $v)%expr_pat)%expr)%expr_pat)
+                                                      else default
+                                                  | None => default1 tt
+                                                  end
+                                              | _ => default1 tt
+                                              end in
+                             match x2 with
+                             | @expr.App _ _ _ s _ #(idc0)%expr_pat x3 =>
                                  match
-                                   match idc2 with
-                                   | @ident.Literal t3 v =>
-                                       match
-                                         t3 as t4
-                                         return
-                                           (base.base_interp t4 -> option Z)
-                                       with
-                                       | base.type.unit =>
-                                           fun _ : unit => None
-                                       | base.type.Z => fun v0 : Z => Some v0
-                                       | base.type.bool =>
-                                           fun _ : bool => None
-                                       | base.type.nat => fun _ : nat => None
-                                       end v
+                                   match idc0 with
+                                   | ident.Z_opp => Some tt
                                    | _ => None
                                    end
                                  with
                                  | Some _ =>
-                                     if (args =? 0) && (args0 =? 0)
-                                     then
-                                      UnderLets.Base
-                                        (x2, ##(0)%expr)%expr_pat
-                                     else
-                                      if args =? 0
-                                      then
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_get_carry)%expr @ x @
-                                          x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                      else
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 | None =>
-                                     if args =? 0
-                                     then
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_get_carry)%expr @ x @
-                                         x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                     else
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_with_get_carry)%expr @
-                                         x @ x0 @ x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 end
-                             | ($_)%expr =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | _ =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                        end
-                    | @expr.App _ _ _ s _ ($_)%expr _ =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t3 v0 =>
-                                   match
-                                     t3 as t4
-                                     return (base.base_interp t4 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v1 : Z => Some v1
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v0
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x2, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v0 : var
+                                     match
+                                       s as t2
+                                       return
+                                         (Compile.value' false t2 ->
+                                          UnderLets.UnderLets base.type ident
+                                            var
+                                            (defaults.expr
                                                (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         end
-                    | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _
-                      _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x2, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | _ =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x2, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    end
-                | None =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            if
-                             (args0 <=? 0) && (args <=? 0) &&
-                             (args0 + args <? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                ##((- args)%Z)%expr @ x1 @
-                                ##((- args0)%Z)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                            else
-                             match x with
-                             | #(idc2)%expr_pat =>
-                                 match
-                                   match idc2 with
-                                   | @ident.Literal t3 v =>
-                                       match
-                                         t3 as t4
-                                         return
-                                           (base.base_interp t4 -> option Z)
-                                       with
-                                       | base.type.unit =>
-                                           fun _ : unit => None
-                                       | base.type.Z => fun v0 : Z => Some v0
-                                       | base.type.bool =>
-                                           fun _ : bool => None
-                                       | base.type.nat => fun _ : nat => None
-                                       end v
-                                   | _ => None
-                                   end
-                                 with
-                                 | Some _ =>
-                                     if (args =? 0) && (args0 =? 0)
-                                     then
-                                      UnderLets.Base
-                                        (x1, ##(0)%expr)%expr_pat
-                                     else
-                                      if args =? 0
-                                      then
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_get_carry)%expr @ x @
-                                          x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                      else
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 | None =>
-                                     if args =? 0
-                                     then
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_get_carry)%expr @ x @
-                                         x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                     else
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_with_get_carry)%expr @
-                                         x @ x0 @ x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
+                                                  (base.type.Z * base.type.Z)%etype)))
+                                     with
+                                     | type.base t2 =>
+                                         fun v : defaults.expr (type.base t2)
+                                         =>
+                                         base.try_make_transport_cps
+                                           (fun t1 : base.type =>
+                                            defaults.expr (type.base t1)) t2
+                                           base.type.Z
+                                           (UnderLets.UnderLets base.type
+                                              ident var
+                                              (defaults.expr
                                                  (type.base
                                                     (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 end
-                             | ($_)%expr =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | _ =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                        | None =>
-                            if args =? 0
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s _ #(idc1)%expr_pat x3 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args =? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_get_borrow)%expr @ x @
-                                           x1 @ x' v)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        match
-                                          s as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t4 : base.type =>
-                                               defaults.expr (type.base t4))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   if args <? 0
-                                                   then
-                                                    UnderLets.UnderLet
-                                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                                       x @
-                                                       ##((- args)%Z)%expr @
-                                                       x1 @ x'0 v0)%expr_pat
-                                                      (fun
-                                                         v1 : var
-                                                                (type.base
-                                                                   (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                       =>
-                                                       UnderLets.Base
-                                                         (#(ident.fst)%expr @
-                                                          ($v1)%expr,
-                                                         (-
-                                                          (#(ident.snd)%expr @
-                                                           $v1)%expr_pat)%expr)%expr_pat)
-                                                   else
-                                                    if args =? 0
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_get_carry)%expr @
-                                                        x @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                    else
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (#(ident.Z_add_with_get_carry)%expr @
-                                                      x @ x0 @ x1 @ x2)%expr_pat
-                                               end)
-                                        | (s0 -> d0)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s0 ->
-                                                  Compile.value' true d0 =>
-                                            UnderLets.Base
-                                              (#(ident.Z_add_with_get_carry)%expr @
-                                               x @ x0 @ x1 @ x2)%expr_pat
-                                        end (Compile.reflect x3)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s0 -> d0)%ptype =>
-                                fun
-                                  _ : Compile.value' false s0 ->
-                                      Compile.value' true d0 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            if args =? 0
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | @expr.App _ _ _ s _ ($_)%expr _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _
-                      _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                end
-            | ($_)%expr =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t3 v0 =>
-                                   match
-                                     t3 as t4
-                                     return (base.base_interp t4 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v1 : Z => Some v1
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v0
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s _ #(idc0)%expr_pat x3 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v0)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v1 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t4 : base.type =>
-                                           defaults.expr (type.base t4)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
-                                                    (defaults.expr
-                                                       (type.base t3) ->
-                                                     defaults.expr
-                                                       (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v1)%expr_pat
-                                                  (fun
-                                                     v2 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v2)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v2)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s0 -> d0)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s0 ->
-                                              Compile.value' true d0 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x3)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _
-                  _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | @expr.Abs _ _ _ _ _ _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x3 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s0 as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v0 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t1 : base.type =>
-                                           defaults.expr (type.base t1)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
+                                                     base.type.Z)%etype)))
+                                           (fun
+                                              a : option
                                                     (defaults.expr
-                                                       (type.base t3) ->
+                                                       (type.base t2) ->
                                                      defaults.expr
                                                        (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v0)%expr_pat
-                                                  (fun
-                                                     v1 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v1)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v1)%expr_pat)%expr)%expr_pat)
-                                               else
+                                            =>
+                                            match a with
+                                            | Some x' =>
                                                 if args =? 0
                                                 then
                                                  UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
+                                                   (#(ident.Z_sub_get_borrow)%expr @
+                                                    x @ x1 @ x' v)%expr_pat
                                                    (fun
-                                                      v1 : var
+                                                      v0 : var
                                                              (type.base
                                                                 (base.type.Z *
                                                                  base.type.Z)%etype)
                                                     =>
                                                     UnderLets.Base
                                                       (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
+                                                       ($v0)%expr,
+                                                      (-
+                                                       (#(ident.snd)%expr @
+                                                        $v0)%expr_pat)%expr)%expr_pat)
                                                 else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
+                                                 match
+                                                   s as t3
+                                                   return
+                                                     (Compile.value' false t3 ->
+                                                      UnderLets.UnderLets
+                                                        base.type ident var
+                                                        (defaults.expr
+                                                           (type.base
+                                                              (base.type.Z *
+                                                               base.type.Z)%etype)))
+                                                 with
+                                                 | type.base t3 =>
+                                                     fun
+                                                       v0 : defaults.expr
+                                                              (type.base t3)
+                                                     =>
+                                                     base.try_make_transport_cps
+                                                       (fun t1 : base.type =>
+                                                        defaults.expr
+                                                          (type.base t1)) t3
+                                                       base.type.Z
+                                                       (UnderLets.UnderLets
+                                                          base.type ident var
+                                                          (defaults.expr
                                                              (type.base
                                                                 (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s1 -> d1)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s1 ->
-                                              Compile.value' true d1 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x3)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
+                                                                 base.type.Z)%etype)))
+                                                       (fun
+                                                          a0 : option
+                                                                 (defaults.expr
+                                                                    (type.base
+                                                                    t3) ->
+                                                                  defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                        =>
+                                                        match a0 with
+                                                        | Some x'0 =>
+                                                            if args <? 0
+                                                            then
+                                                             UnderLets.UnderLet
+                                                               (#(ident.Z_sub_with_get_borrow)%expr @
+                                                                x @
+                                                                ##((- args)%Z)%expr @
+                                                                x1 @ 
+                                                                x'0 v0)%expr_pat
+                                                               (fun
+                                                                  v1 : 
+                                                                   var
+                                                                    (type.base
+                                                                    (base.type.Z *
+                                                                    base.type.Z)%etype)
+                                                                =>
+                                                                UnderLets.Base
+                                                                  (#(ident.fst)%expr @
+                                                                   ($v1)%expr,
+                                                                  (-
+                                                                   (#
+                                                                    (ident.snd)%expr @
+                                                                    $v1)%expr_pat)%expr)%expr_pat)
+                                                            else default
+                                                        | None => default
+                                                        end)
+                                                 | (s0 -> d0)%ptype =>
+                                                     fun
+                                                       _ : Compile.value'
+                                                             false s0 ->
+                                                           Compile.value'
+                                                             true d0 =>
+                                                     default
+                                                 end (Compile.reflect x3)
+                                            | None => default
+                                            end)
+                                     | (s0 -> d0)%ptype =>
+                                         fun
+                                           _ : Compile.value' false s0 ->
+                                               Compile.value' true d0 =>
+                                         default
+                                     end (Compile.reflect x3)
+                                 | None => default
+                                 end
+                             | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _
+                               _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                               _ _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _ _
+                               s _ (@expr.LetIn _ _ _ _ _ _ _) _ => default
+                             | _ => default1 tt
+                             end in
+            match x1 with
             | @expr.App _ _ _ s _ #(idc0)%expr_pat x3 =>
                 match
                   match idc0 with
@@ -9270,387 +4434,83 @@ match idc in (ident t) return (Compile.value' true t) with
                                                   ($v1)%expr,
                                                  (-
                                                   (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                           else
-                                            match x2 with
-                                            | #(idc1)%expr_pat =>
-                                                match
-                                                  match idc1 with
-                                                  | @ident.Literal t4 v1 =>
-                                                      match
-                                                        t4 as t5
-                                                        return
-                                                          (base.base_interp
-                                                             t5 -> option Z)
-                                                      with
-                                                      | base.type.unit =>
-                                                          fun _ : unit =>
-                                                          None
-                                                      | base.type.Z =>
-                                                          fun v2 : Z =>
-                                                          Some v2
-                                                      | base.type.bool =>
-                                                          fun _ : bool =>
-                                                          None
-                                                      | base.type.nat =>
-                                                          fun _ : nat => None
-                                                      end v1
-                                                  | _ => None
-                                                  end
-                                                with
-                                                | Some args1 =>
-                                                    if
-                                                     (args1 <=? 0) &&
-                                                     (args <=? 0) &&
-                                                     (args1 + args <? 0)
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_sub_with_get_borrow)%expr @
-                                                        x @
-                                                        ##((- args)%Z)%expr @
-                                                        x1 @
-                                                        ##((- args1)%Z)%expr)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          (-
-                                                           (#(ident.snd)%expr @
-                                                            $v1)%expr_pat)%expr)%expr_pat)
-                                                    else
-                                                     match x with
-                                                     | #(idc2)%expr_pat =>
-                                                         match
-                                                           match idc2 with
-                                                           | @ident.Literal
-                                                             t5 v1 =>
-                                                               match
-                                                                 t5 as t6
-                                                                 return
-                                                                   (base.base_interp
-                                                                    t6 ->
+                                           else default
+                                       | None => default
+                                       end)
+                                | (s0 -> d0)%ptype =>
+                                    fun
+                                      _ : Compile.value' false s0 ->
+                                          Compile.value' true d0 => default
+                                end (Compile.reflect x3)
+                           | None => default
+                           end)
+                    | (s0 -> d0)%ptype =>
+                        fun
+                          _ : Compile.value' false s0 ->
+                              Compile.value' true d0 => default
+                    end (Compile.reflect x3)
+                | None => default
+                end
+            | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
+              (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
+              (@expr.LetIn _ _ _ _ _ _ _) _ => default
+            | _ => default1 tt
+            end
+        | None => default0 tt
+        end
+    | @expr.App _ _ _ s _ #(idc)%expr_pat x3 =>
+        match match idc with
+              | ident.Z_opp => Some tt
+              | _ => None
+              end with
+        | Some _ =>
+            llet default1 := fun 'tt =>
+                             llet default1 := fun 'tt =>
+                                              llet default1 := fun 'tt =>
+                                                               match x2 with
+                                                               | #(idc0)%expr_pat =>
+                                                                   match
+                                                                    match
+                                                                    idc0
+                                                                    with
+                                                                    | @ident.Literal
+                                                                    t1 v =>
+                                                                    match
+                                                                    t1 as t2
+                                                                    return
+                                                                    (base.base_interp
+                                                                    t2 ->
                                                                     option Z)
-                                                               with
-                                                               | base.type.unit =>
-                                                                   fun
+                                                                    with
+                                                                    | base.type.unit =>
+                                                                    fun
                                                                     _ : unit
-                                                                   => None
-                                                               | base.type.Z =>
-                                                                   fun v2 : Z
-                                                                   => 
-                                                                   Some v2
-                                                               | base.type.bool =>
-                                                                   fun
+                                                                    => None
+                                                                    | base.type.Z =>
+                                                                    fun
+                                                                    v0 : Z =>
+                                                                    Some v0
+                                                                    | base.type.bool =>
+                                                                    fun
                                                                     _ : bool
-                                                                   => None
-                                                               | base.type.nat =>
-                                                                   fun
+                                                                    => None
+                                                                    | base.type.nat =>
+                                                                    fun
                                                                     _ : nat
-                                                                   => None
-                                                               end v1
-                                                           | _ => None
-                                                           end
-                                                         with
-                                                         | Some _ =>
-                                                             if
-                                                              (args =? 0) &&
-                                                              (args1 =? 0)
-                                                             then
-                                                              UnderLets.Base
-                                                                (x1,
-                                                                ##(0)%expr)%expr_pat
-                                                             else
-                                                              if args =? 0
-                                                              then
-                                                               UnderLets.UnderLet
-                                                                 (#(ident.Z_add_get_carry)%expr @
-                                                                  x @ x1 @ x2)%expr_pat
-                                                                 (fun
-                                                                    v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                  =>
-                                                                  UnderLets.Base
-                                                                    (
-                                                                    #
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                    #
-                                                                    (ident.snd)%expr @
-                                                                    ($v1)%expr)%expr_pat)
-                                                              else
-                                                               UnderLets.UnderLet
-                                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                                  x @ x0 @ x1 @
-                                                                  x2)%expr_pat
-                                                                 (fun
-                                                                    v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                  =>
-                                                                  UnderLets.Base
-                                                                    (
-                                                                    #
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                    #
-                                                                    (ident.snd)%expr @
-                                                                    ($v1)%expr)%expr_pat)
-                                                         | None =>
-                                                             if args =? 0
-                                                             then
-                                                              UnderLets.UnderLet
-                                                                (#(ident.Z_add_get_carry)%expr @
-                                                                 x @ x1 @ x2)%expr_pat
-                                                                (fun
-                                                                   v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                 =>
-                                                                 UnderLets.Base
-                                                                   (#
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                   #(ident.snd)%expr @
-                                                                   ($v1)%expr)%expr_pat)
-                                                             else
-                                                              UnderLets.UnderLet
-                                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                                 x @ x0 @ x1 @
-                                                                 x2)%expr_pat
-                                                                (fun
-                                                                   v1 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                 =>
-                                                                 UnderLets.Base
-                                                                   (#
-                                                                    (ident.fst)%expr @
-                                                                    ($v1)%expr,
-                                                                   #(ident.snd)%expr @
-                                                                   ($v1)%expr)%expr_pat)
-                                                         end
-                                                     | ($_)%expr =>
-                                                         if args =? 0
-                                                         then
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_get_carry)%expr @
-                                                             x @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v2 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v2)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v2)%expr)%expr_pat)
-                                                         else
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_with_get_carry)%expr @
-                                                             x @ x0 @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v2 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v2)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v2)%expr)%expr_pat)
-                                                     | _ =>
-                                                         if args =? 0
-                                                         then
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_get_carry)%expr @
-                                                             x @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v1 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v1)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v1)%expr)%expr_pat)
-                                                         else
-                                                          UnderLets.UnderLet
-                                                            (#(ident.Z_add_with_get_carry)%expr @
-                                                             x @ x0 @ x1 @ x2)%expr_pat
-                                                            (fun
-                                                               v1 : var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                             =>
-                                                             UnderLets.Base
-                                                               (#(ident.fst)%expr @
-                                                                ($v1)%expr,
-                                                               #(ident.snd)%expr @
-                                                               ($v1)%expr)%expr_pat)
-                                                     end
-                                                | None =>
-                                                    if args =? 0
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_get_carry)%expr @
-                                                        x @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                    else
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                end
-                                            | ($_)%expr =>
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                            | @expr.App _ _ _ s0 _
-                                              #(idc1)%expr_pat x4 =>
-                                                match
-                                                  match idc1 with
-                                                  | ident.Z_opp => Some tt
-                                                  | _ => None
-                                                  end
-                                                with
-                                                | Some _ =>
-                                                    match
-                                                      s0 as t4
-                                                      return
-                                                        (Compile.value' false
-                                                           t4 ->
-                                                         UnderLets.UnderLets
-                                                           base.type ident
-                                                           var
-                                                           (defaults.expr
-                                                              (type.base
-                                                                 (base.type.Z *
-                                                                  base.type.Z)%etype)))
-                                                    with
-                                                    | type.base t4 =>
-                                                        fun
-                                                          v1 : defaults.expr
-                                                                 (type.base
-                                                                    t4) =>
-                                                        base.try_make_transport_cps
-                                                          (fun t5 : base.type
-                                                           =>
-                                                           defaults.expr
-                                                             (type.base t5))
-                                                          t4 base.type.Z
-                                                          (UnderLets.UnderLets
-                                                             base.type ident
-                                                             var
-                                                             (defaults.expr
-                                                                (type.base
-                                                                   (base.type.Z *
-                                                                    base.type.Z)%etype)))
-                                                          (fun
-                                                             a1 : option
-                                                                    (defaults.expr
-                                                                    (type.base
-                                                                    t4) ->
-                                                                    defaults.expr
-                                                                    (type.base
-                                                                    base.type.Z))
-                                                           =>
-                                                           match a1 with
-                                                           | Some x'1 =>
-                                                               if args =? 0
-                                                               then
-                                                                UnderLets.UnderLet
-                                                                  (#(ident.Z_sub_get_borrow)%expr @
-                                                                   x @ x1 @
-                                                                   x'1 v1)%expr_pat
-                                                                  (fun
-                                                                    v2 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                                   =>
-                                                                   UnderLets.Base
-                                                                    (
-                                                                    #
-                                                                    (ident.fst)%expr @
-                                                                    ($v2)%expr,
-                                                                    (-
-                                                                    (#
-                                                                    (ident.snd)%expr @
-                                                                    $v2)%expr_pat)%expr)%expr_pat)
-                                                               else
-                                                                match
-                                                                  s0 as t5
-                                                                  return
+                                                                    => None
+                                                                    end v
+                                                                    | _ =>
+                                                                    None
+                                                                    end
+                                                                   with
+                                                                   | Some
+                                                                    args0 =>
+                                                                    match
+                                                                    s as t2
+                                                                    return
                                                                     (Compile.value'
-                                                                    false t5 ->
+                                                                    false t2 ->
                                                                     UnderLets.UnderLets
                                                                     base.type
                                                                     ident var
@@ -9658,21 +4518,21 @@ match idc in (ident t) return (Compile.value' true t) with
                                                                     (type.base
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)))
-                                                                with
-                                                                | type.base
-                                                                  t5 =>
+                                                                    with
+                                                                    | type.base
+                                                                    t2 =>
                                                                     fun
-                                                                    v2 : 
+                                                                    v : 
                                                                     defaults.expr
                                                                     (type.base
-                                                                    t5) =>
+                                                                    t2) =>
                                                                     base.try_make_transport_cps
                                                                     (fun
-                                                                    t6 : base.type
+                                                                    t1 : base.type
                                                                     =>
                                                                     defaults.expr
                                                                     (type.base
-                                                                    t6)) t5
+                                                                    t1)) t2
                                                                     base.type.Z
                                                                     (UnderLets.UnderLets
                                                                     base.type
@@ -9682,33 +4542,33 @@ match idc in (ident t) return (Compile.value' true t) with
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)))
                                                                     (fun
-                                                                    a2 : 
+                                                                    a : 
                                                                     option
                                                                     (defaults.expr
                                                                     (type.base
-                                                                    t5) ->
+                                                                    t2) ->
                                                                     defaults.expr
                                                                     (type.base
                                                                     base.type.Z))
                                                                     =>
                                                                     match
-                                                                    a2
+                                                                    a
                                                                     with
                                                                     | Some
-                                                                    x'2 =>
+                                                                    x' =>
                                                                     if
-                                                                    args <? 0
+                                                                    args0 <=?
+                                                                    0
                                                                     then
                                                                     UnderLets.UnderLet
                                                                     (#
                                                                     (ident.Z_sub_with_get_borrow)%expr @
-                                                                    x @
+                                                                    x @ 
+                                                                    x' v @ x1 @
                                                                     ##
-                                                                    ((- args)%Z)%expr @
-                                                                    x1 @
-                                                                    x'2 v2)%expr_pat
+                                                                    ((- args0)%Z)%expr)%expr_pat
                                                                     (fun
-                                                                    v3 : 
+                                                                    v0 : 
                                                                     var
                                                                     (type.base
                                                                     (base.type.Z *
@@ -9718,43 +4578,118 @@ match idc in (ident t) return (Compile.value' true t) with
                                                                     (
                                                                     #
                                                                     (ident.fst)%expr @
-                                                                    ($v3)%expr,
+                                                                    ($v0)%expr,
                                                                     (-
                                                                     (#
                                                                     (ident.snd)%expr @
-                                                                    $v3)%expr_pat)%expr)%expr_pat)
+                                                                    $v0)%expr_pat)%expr)%expr_pat)
                                                                     else
-                                                                    if
-                                                                    args =? 0
-                                                                    then
-                                                                    UnderLets.UnderLet
-                                                                    (#
-                                                                    (ident.Z_add_get_carry)%expr @
-                                                                    x @ x1 @
-                                                                    x2)%expr_pat
-                                                                    (fun
-                                                                    v3 : 
-                                                                    var
-                                                                    (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
+                                                                    default
+                                                                    | None =>
+                                                                    default
+                                                                    end)
+                                                                    | (s0 ->
+                                                                    d0)%ptype =>
+                                                                    fun
+                                                                    _ : 
+                                                                    Compile.value'
+                                                                    false s0 ->
+                                                                    Compile.value'
+                                                                    true d0
                                                                     =>
-                                                                    UnderLets.Base
-                                                                    (
-                                                                    #
-                                                                    (ident.fst)%expr @
-                                                                    ($v3)%expr,
-                                                                    #
-                                                                    (ident.snd)%expr @
-                                                                    ($v3)%expr)%expr_pat)
-                                                                    else
-                                                                    UnderLets.UnderLet
+                                                                    default
+                                                                    end
+                                                                    (Compile.reflect
+                                                                    x3)
+                                                                   | None =>
+                                                                    default
+                                                                   end
+                                                               | _ => default
+                                                               end in
+                                              match x1 with
+                                              | #(idc0)%expr_pat =>
+                                                  match
+                                                    match idc0 with
+                                                    | @ident.Literal t1 v =>
+                                                        match
+                                                          t1 as t2
+                                                          return
+                                                            (base.base_interp
+                                                               t2 -> 
+                                                             option Z)
+                                                        with
+                                                        | base.type.unit =>
+                                                            fun _ : unit =>
+                                                            None
+                                                        | base.type.Z =>
+                                                            fun v0 : Z =>
+                                                            Some v0
+                                                        | base.type.bool =>
+                                                            fun _ : bool =>
+                                                            None
+                                                        | base.type.nat =>
+                                                            fun _ : nat =>
+                                                            None
+                                                        end v
+                                                    | _ => None
+                                                    end
+                                                  with
+                                                  | Some args0 =>
+                                                      match
+                                                        s as t2
+                                                        return
+                                                          (Compile.value'
+                                                             false t2 ->
+                                                           UnderLets.UnderLets
+                                                             base.type ident
+                                                             var
+                                                             (defaults.expr
+                                                                (type.base
+                                                                   (base.type.Z *
+                                                                    base.type.Z)%etype)))
+                                                      with
+                                                      | type.base t2 =>
+                                                          fun
+                                                            v : defaults.expr
+                                                                  (type.base
+                                                                    t2) =>
+                                                          base.try_make_transport_cps
+                                                            (fun
+                                                               t1 : base.type
+                                                             =>
+                                                             defaults.expr
+                                                               (type.base t1))
+                                                            t2 base.type.Z
+                                                            (UnderLets.UnderLets
+                                                               base.type
+                                                               ident var
+                                                               (defaults.expr
+                                                                  (type.base
+                                                                    (base.type.Z *
+                                                                    base.type.Z)%etype)))
+                                                            (fun
+                                                               a : option
+                                                                    (defaults.expr
+                                                                    (type.base
+                                                                    t2) ->
+                                                                    defaults.expr
+                                                                    (type.base
+                                                                    base.type.Z))
+                                                             =>
+                                                             match a with
+                                                             | Some x' =>
+                                                                 if
+                                                                  args0 <=? 0
+                                                                 then
+                                                                  UnderLets.UnderLet
                                                                     (#
-                                                                    (ident.Z_add_with_get_carry)%expr @
-                                                                    x @ x0 @
-                                                                    x1 @ x2)%expr_pat
+                                                                    (ident.Z_sub_with_get_borrow)%expr @
+                                                                    x @ 
+                                                                    x' v @ x2 @
+                                                                    ##
+                                                                    ((- args0)%Z)%expr)%expr_pat
                                                                     (fun
-                                                                    v3 : 
+                                                                    v0 : 
                                                                     var
                                                                     (type.base
                                                                     (base.type.Z *
@@ -9764,4801 +4699,151 @@ match idc in (ident t) return (Compile.value' true t) with
                                                                     (
                                                                     #
                                                                     (ident.fst)%expr @
-                                                                    ($v3)%expr,
-                                                                    #
-                                                                    (ident.snd)%expr @
-                                                                    ($v3)%expr)%expr_pat)
-                                                                    | None =>
-                                                                    UnderLets.Base
-                                                                    (#
-                                                                    (ident.Z_add_with_get_carry)%expr @
-                                                                    x @ x0 @
-                                                                    x1 @ x2)%expr_pat
-                                                                    end)
-                                                                | (s1 -> d1)%ptype =>
-                                                                    fun
-                                                                    _ : 
-                                                                    Compile.value'
-                                                                    false s1 ->
-                                                                    Compile.value'
-                                                                    true d1
-                                                                    =>
-                                                                    UnderLets.Base
+                                                                    ($v0)%expr,
+                                                                    (-
                                                                     (#
-                                                                    (ident.Z_add_with_get_carry)%expr @
-                                                                    x @ x0 @
-                                                                    x1 @ x2)%expr_pat
-                                                                end
-                                                                  (Compile.reflect
-                                                                    x4)
-                                                           | None =>
-                                                               UnderLets.Base
-                                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                                  x @ x0 @ x1 @
-                                                                  x2)%expr_pat
-                                                           end)
-                                                    | (s1 -> d1)%ptype =>
-                                                        fun
-                                                          _ : Compile.value'
-                                                                false s1 ->
-                                                              Compile.value'
-                                                                true d1 =>
-                                                        UnderLets.Base
-                                                          (#(ident.Z_add_with_get_carry)%expr @
-                                                           x @ x0 @ x1 @ x2)%expr_pat
-                                                    end (Compile.reflect x4)
-                                                | None =>
-                                                    if args =? 0
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_get_carry)%expr @
-                                                        x @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                    else
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                end
-                                            | @expr.App _ _ _ s0 _ ($_)%expr
-                                              _ =>
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                            | @expr.App _ _ _ s0 _
-                                              (@expr.Abs _ _ _ _ _ _) _ |
-                                              @expr.App _ _ _ s0 _
-                                              (_ @ _)%expr_pat _ | @expr.App
-                                              _ _ _ s0 _
-                                              (@expr.LetIn _ _ _ _ _ _ _)
-                                              _ =>
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                            | _ =>
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                            end
-                                       | None =>
-                                           UnderLets.Base
-                                             (#(ident.Z_add_with_get_carry)%expr @
-                                              x @ x0 @ x1 @ x2)%expr_pat
-                                       end)
-                                | (s0 -> d0)%ptype =>
-                                    fun
-                                      _ : Compile.value' false s0 ->
-                                          Compile.value' true d0 =>
-                                    UnderLets.Base
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                end (Compile.reflect x3)
-                           | None =>
-                               UnderLets.Base
-                                 (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                  x1 @ x2)%expr_pat
-                           end)
-                    | (s0 -> d0)%ptype =>
-                        fun
-                          _ : Compile.value' false s0 ->
-                              Compile.value' true d0 =>
-                        UnderLets.Base
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                    end (Compile.reflect x3)
-                | None =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            if
-                             (args0 <=? 0) && (args <=? 0) &&
-                             (args0 + args <? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                                ##((- args)%Z)%expr @ x1 @
-                                ##((- args0)%Z)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                            else
-                             match x with
-                             | #(idc2)%expr_pat =>
+                                                                    (ident.snd)%expr @
+                                                                    $v0)%expr_pat)%expr)%expr_pat)
+                                                                 else default
+                                                             | None =>
+                                                                 default
+                                                             end)
+                                                      | (s0 -> d0)%ptype =>
+                                                          fun
+                                                            _ : Compile.value'
+                                                                  false s0 ->
+                                                                Compile.value'
+                                                                  true d0 =>
+                                                          default
+                                                      end
+                                                        (Compile.reflect x3)
+                                                  | None => default1 tt
+                                                  end
+                                              | _ => default1 tt
+                                              end in
+                             match x2 with
+                             | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x4 =>
                                  match
-                                   match idc2 with
-                                   | @ident.Literal t3 v =>
-                                       match
-                                         t3 as t4
-                                         return
-                                           (base.base_interp t4 -> option Z)
-                                       with
-                                       | base.type.unit =>
-                                           fun _ : unit => None
-                                       | base.type.Z => fun v0 : Z => Some v0
-                                       | base.type.bool =>
-                                           fun _ : bool => None
-                                       | base.type.nat => fun _ : nat => None
-                                       end v
+                                   match idc0 with
+                                   | ident.Z_opp => Some tt
                                    | _ => None
                                    end
                                  with
                                  | Some _ =>
-                                     if (args =? 0) && (args0 =? 0)
-                                     then
-                                      UnderLets.Base
-                                        (x1, ##(0)%expr)%expr_pat
-                                     else
-                                      if args =? 0
-                                      then
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_get_carry)%expr @ x @
-                                          x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                      else
-                                       UnderLets.UnderLet
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                         (fun
-                                            v : var
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype) =>
-                                          UnderLets.Base
-                                            (#(ident.fst)%expr @ ($v)%expr,
-                                            #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 | None =>
-                                     if args =? 0
-                                     then
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_get_carry)%expr @ x @
-                                         x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                     else
-                                      UnderLets.UnderLet
-                                        (#(ident.Z_add_with_get_carry)%expr @
-                                         x @ x0 @ x1 @ x2)%expr_pat
-                                        (fun
-                                           v : var
+                                     match
+                                       s as t2
+                                       return
+                                         (Compile.value' false t2 ->
+                                          UnderLets.UnderLets base.type ident
+                                            var
+                                            (defaults.expr
+                                               (type.base
+                                                  (base.type.Z * base.type.Z)%etype)))
+                                     with
+                                     | type.base t2 =>
+                                         fun v : defaults.expr (type.base t2)
+                                         =>
+                                         base.try_make_transport_cps
+                                           (fun t1 : base.type =>
+                                            defaults.expr (type.base t1)) t2
+                                           base.type.Z
+                                           (UnderLets.UnderLets base.type
+                                              ident var
+                                              (defaults.expr
                                                  (type.base
                                                     (base.type.Z *
-                                                     base.type.Z)%etype) =>
-                                         UnderLets.Base
-                                           (#(ident.fst)%expr @ ($v)%expr,
-                                           #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 end
-                             | ($_)%expr =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | _ =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                        | None =>
-                            if args =? 0
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s0 _ #(idc1)%expr_pat x4 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s0 as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args =? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_get_borrow)%expr @ x @
-                                           x1 @ x' v)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        match
-                                          s0 as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t4 : base.type =>
-                                               defaults.expr (type.base t4))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   if args <? 0
-                                                   then
-                                                    UnderLets.UnderLet
-                                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                                       x @
-                                                       ##((- args)%Z)%expr @
-                                                       x1 @ x'0 v0)%expr_pat
-                                                      (fun
-                                                         v1 : var
-                                                                (type.base
-                                                                   (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                       =>
-                                                       UnderLets.Base
-                                                         (#(ident.fst)%expr @
-                                                          ($v1)%expr,
-                                                         (-
-                                                          (#(ident.snd)%expr @
-                                                           $v1)%expr_pat)%expr)%expr_pat)
-                                                   else
-                                                    if args =? 0
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_get_carry)%expr @
-                                                        x @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                                    else
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (#(ident.Z_add_with_get_carry)%expr @
-                                                      x @ x0 @ x1 @ x2)%expr_pat
-                                               end)
-                                        | (s1 -> d1)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s1 ->
-                                                  Compile.value' true d1 =>
-                                            UnderLets.Base
-                                              (#(ident.Z_add_with_get_carry)%expr @
-                                               x @ x0 @ x1 @ x2)%expr_pat
-                                        end (Compile.reflect x4)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s1 -> d1)%ptype =>
-                                fun
-                                  _ : Compile.value' false s1 ->
-                                      Compile.value' true d1 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x4)
-                        | None =>
-                            if args =? 0
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _
-                      _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | _ =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                end
-            | @expr.App _ _ _ s _ ($_)%expr _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              (- (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t3 v0 =>
-                                   match
-                                     t3 as t4
-                                     return (base.base_interp t4 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v1 : Z => Some v1
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v0
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v0 : var
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v0)%expr,
-                                        #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v0 : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v0)%expr,
-                                       #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v1 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v1)%expr,
-                                   #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x4 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v0)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s0 as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v1 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t4 : base.type =>
-                                           defaults.expr (type.base t4)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
-                                                    (defaults.expr
-                                                       (type.base t3) ->
-                                                     defaults.expr
-                                                       (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v1)%expr_pat
-                                                  (fun
-                                                     v2 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v2)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v2)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v2 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v2)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v2)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s1 -> d1)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s1 ->
-                                              Compile.value' true d1 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x4)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x4)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v1 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v1)%expr,
-                          #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ #(idc0)%expr_pat x4 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s1 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s1 as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v0 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t1 : base.type =>
-                                           defaults.expr (type.base t1)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
-                                                    (defaults.expr
-                                                       (type.base t3) ->
-                                                     defaults.expr
-                                                       (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v0)%expr_pat
-                                                  (fun
-                                                     v1 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v1)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v1)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s2 -> d2)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s2 ->
-                                              Compile.value' true d2 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x4)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x4)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s _ (_ @ _)%expr_pat _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ #(idc0)%expr_pat x5 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s1 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s1 as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v0 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t1 : base.type =>
-                                           defaults.expr (type.base t1)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
-                                                    (defaults.expr
-                                                       (type.base t3) ->
-                                                     defaults.expr
-                                                       (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v0)%expr_pat
-                                                  (fun
-                                                     v1 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v1)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v1)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s2 -> d2)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s2 ->
-                                              Compile.value' true d2 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x5)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x5)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x5 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s0 as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s0 as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v0 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t1 : base.type =>
-                                           defaults.expr (type.base t1)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
+                                                     base.type.Z)%etype)))
+                                           (fun
+                                              a : option
                                                     (defaults.expr
-                                                       (type.base t3) ->
+                                                       (type.base t2) ->
                                                      defaults.expr
                                                        (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v0)%expr_pat
-                                                  (fun
-                                                     v1 : var
-                                                            (type.base
-                                                               (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v1)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v1)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
+                                            =>
+                                            match a with
+                                            | Some x' =>
+                                                match
+                                                  s0 as t3
+                                                  return
+                                                    (Compile.value' false t3 ->
+                                                     UnderLets.UnderLets
+                                                       base.type ident var
+                                                       (defaults.expr
+                                                          (type.base
+                                                             (base.type.Z *
+                                                              base.type.Z)%etype)))
+                                                with
+                                                | type.base t3 =>
+                                                    fun
+                                                      v0 : defaults.expr
+                                                             (type.base t3)
                                                     =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s1 -> d1)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s1 ->
-                                              Compile.value' true d1 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x5)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x5)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.LetIn _ _ _ _ _ _ _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if
-                         (args0 <=? 0) && (args <=? 0) && (args0 + args <? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_sub_with_get_borrow)%expr @ x @
-                            ##((- args)%Z)%expr @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              (- (#(ident.snd)%expr @ $v)%expr_pat)%expr)%expr_pat)
-                        else
-                         match x with
-                         | #(idc1)%expr_pat =>
-                             match
-                               match idc1 with
-                               | @ident.Literal t2 v =>
-                                   match
-                                     t2 as t3
-                                     return (base.base_interp t3 -> option Z)
-                                   with
-                                   | base.type.unit => fun _ : unit => None
-                                   | base.type.Z => fun v0 : Z => Some v0
-                                   | base.type.bool => fun _ : bool => None
-                                   | base.type.nat => fun _ : nat => None
-                                   end v
-                               | _ => None
-                               end
-                             with
-                             | Some _ =>
-                                 if (args =? 0) && (args0 =? 0)
-                                 then
-                                  UnderLets.Base (x1, ##(0)%expr)%expr_pat
-                                 else
-                                  if args =? 0
-                                  then
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                      x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                  else
-                                   UnderLets.UnderLet
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                                     (fun
-                                        v : var
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)
-                                      =>
-                                      UnderLets.Base
-                                        (#(ident.fst)%expr @ ($v)%expr,
-                                        #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             | None =>
-                                 if args =? 0
-                                 then
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_get_carry)%expr @ x @ x1 @
-                                     x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                                 else
-                                  UnderLets.UnderLet
-                                    (#(ident.Z_add_with_get_carry)%expr @ x @
-                                     x0 @ x1 @ x2)%expr_pat
-                                    (fun
-                                       v : var
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)
-                                     =>
-                                     UnderLets.Base
-                                       (#(ident.fst)%expr @ ($v)%expr,
-                                       #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             end
-                         | ($_)%expr =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v0 : var
-                                          (type.base
-                                             (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v0)%expr,
-                                   #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                         | _ =>
-                             if args =? 0
-                             then
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                             else
-                              UnderLets.UnderLet
-                                (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                 x1 @ x2)%expr_pat
-                                (fun
-                                   v : var
-                                         (type.base
-                                            (base.type.Z * base.type.Z)%etype)
-                                 =>
-                                 UnderLets.Base
-                                   (#(ident.fst)%expr @ ($v)%expr,
-                                   #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                         end
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s _ #(idc0)%expr_pat x4 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args =? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_get_borrow)%expr @ x @
-                                       x1 @ x' v)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    match
-                                      s as t3
-                                      return
-                                        (Compile.value' false t3 ->
-                                         UnderLets.UnderLets base.type ident
-                                           var
-                                           (defaults.expr
-                                              (type.base
-                                                 (base.type.Z * base.type.Z)%etype)))
-                                    with
-                                    | type.base t3 =>
-                                        fun v0 : defaults.expr (type.base t3)
-                                        =>
-                                        base.try_make_transport_cps
-                                          (fun t1 : base.type =>
-                                           defaults.expr (type.base t1)) t3
-                                          base.type.Z
-                                          (UnderLets.UnderLets base.type
-                                             ident var
-                                             (defaults.expr
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)))
-                                          (fun
-                                             a0 : option
-                                                    (defaults.expr
-                                                       (type.base t3) ->
-                                                     defaults.expr
-                                                       (type.base base.type.Z))
-                                           =>
-                                           match a0 with
-                                           | Some x'0 =>
-                                               if args <? 0
-                                               then
-                                                UnderLets.UnderLet
-                                                  (#(ident.Z_sub_with_get_borrow)%expr @
-                                                   x @ ##((- args)%Z)%expr @
-                                                   x1 @ x'0 v0)%expr_pat
-                                                  (fun
-                                                     v1 : var
+                                                    base.try_make_transport_cps
+                                                      (fun t1 : base.type =>
+                                                       defaults.expr
+                                                         (type.base t1)) t3
+                                                      base.type.Z
+                                                      (UnderLets.UnderLets
+                                                         base.type ident var
+                                                         (defaults.expr
                                                             (type.base
                                                                (base.type.Z *
-                                                                base.type.Z)%etype)
-                                                   =>
-                                                   UnderLets.Base
-                                                     (#(ident.fst)%expr @
-                                                      ($v1)%expr,
-                                                     (-
-                                                      (#(ident.snd)%expr @
-                                                       $v1)%expr_pat)%expr)%expr_pat)
-                                               else
-                                                if args =? 0
-                                                then
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_get_carry)%expr @
-                                                    x @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                                else
-                                                 UnderLets.UnderLet
-                                                   (#(ident.Z_add_with_get_carry)%expr @
-                                                    x @ x0 @ x1 @ x2)%expr_pat
-                                                   (fun
-                                                      v1 : var
-                                                             (type.base
-                                                                (base.type.Z *
-                                                                 base.type.Z)%etype)
-                                                    =>
-                                                    UnderLets.Base
-                                                      (#(ident.fst)%expr @
-                                                       ($v1)%expr,
-                                                      #(ident.snd)%expr @
-                                                      ($v1)%expr)%expr_pat)
-                                           | None =>
-                                               UnderLets.Base
-                                                 (#(ident.Z_add_with_get_carry)%expr @
-                                                  x @ x0 @ x1 @ x2)%expr_pat
-                                           end)
-                                    | (s0 -> d0)%ptype =>
-                                        fun
-                                          _ : Compile.value' false s0 ->
-                                              Compile.value' true d0 =>
-                                        UnderLets.Base
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                    end (Compile.reflect x4)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x4)
-                    | None =>
-                        if args =? 0
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s _ ($_)%expr _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v0 : var
-                                 (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v0)%expr,
-                          #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _
-                  _ _ s _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    if args =? 0
-                    then
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_get_carry)%expr @ x @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    else
-                     UnderLets.UnderLet
-                       (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                       (fun
-                          v : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                        =>
-                        UnderLets.Base
-                          (#(ident.fst)%expr @ ($v)%expr,
-                          #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            end
-        | None =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            if (args =? 0) && (args0 =? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                ##(args)%expr @ ##(args0)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr, ##(0)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | ($_)%expr =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        end
-    | ($_)%expr =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if (args =? 0) && (args0 =? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                            ##(args)%expr @ ##(args0)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr, ##(0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        end
-    | @expr.App _ _ _ s _ #(idc)%expr_pat x3 =>
-        match match idc with
-              | ident.Z_opp => Some tt
-              | _ => None
-              end with
-        | Some _ =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args0 =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args1 =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args0 <=? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_with_get_borrow)%expr @
-                                           x @ x' v @ x2 @
-                                           ##((- args0)%Z)%expr)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        match
-                                          s as t3
-                                          return
-                                            (Compile.value' false t3 ->
-                                             UnderLets.UnderLets base.type
-                                               ident var
-                                               (defaults.expr
-                                                  (type.base
-                                                     (base.type.Z *
-                                                      base.type.Z)%etype)))
-                                        with
-                                        | type.base t3 =>
-                                            fun
-                                              v0 : defaults.expr
-                                                     (type.base t3) =>
-                                            base.try_make_transport_cps
-                                              (fun t4 : base.type =>
-                                               defaults.expr (type.base t4))
-                                              t3 base.type.Z
-                                              (UnderLets.UnderLets base.type
-                                                 ident var
-                                                 (defaults.expr
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)))
-                                              (fun
-                                                 a0 : option
-                                                        (defaults.expr
-                                                           (type.base t3) ->
-                                                         defaults.expr
-                                                           (type.base
-                                                              base.type.Z))
-                                               =>
-                                               match a0 with
-                                               | Some x'0 =>
-                                                   if args1 <=? 0
-                                                   then
-                                                    UnderLets.UnderLet
-                                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                                       x @ x'0 v0 @ x1 @
-                                                       ##((- args1)%Z)%expr)%expr_pat
+                                                                base.type.Z)%etype)))
                                                       (fun
-                                                         v1 : var
-                                                                (type.base
-                                                                   (base.type.Z *
-                                                                    base.type.Z)%etype)
+                                                         a0 : option
+                                                                (defaults.expr
+                                                                   (type.base
+                                                                    t3) ->
+                                                                 defaults.expr
+                                                                   (type.base
+                                                                    base.type.Z))
                                                        =>
-                                                       UnderLets.Base
-                                                         (#(ident.fst)%expr @
-                                                          ($v1)%expr,
-                                                         (-
-                                                          (#(ident.snd)%expr @
-                                                           $v1)%expr_pat)%expr)%expr_pat)
-                                                   else
-                                                    if
-                                                     (args0 =? 0) &&
-                                                     (args1 =? 0)
-                                                    then
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @
-                                                        ##(args0)%expr @
-                                                        ##(args1)%expr)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
-                                                                    (base.type.Z *
-                                                                    base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          ##(0)%expr)%expr_pat)
-                                                    else
-                                                     UnderLets.UnderLet
-                                                       (#(ident.Z_add_with_get_carry)%expr @
-                                                        x @ x0 @ x1 @ x2)%expr_pat
-                                                       (fun
-                                                          v1 : var
-                                                                 (type.base
+                                                       match a0 with
+                                                       | Some x'0 =>
+                                                           UnderLets.UnderLet
+                                                             (#(ident.Z_sub_with_get_borrow)%expr @
+                                                              x @ x' v @ x1 @
+                                                              x'0 v0)%expr_pat
+                                                             (fun
+                                                                v1 : 
+                                                                 var
+                                                                   (type.base
                                                                     (base.type.Z *
                                                                     base.type.Z)%etype)
-                                                        =>
-                                                        UnderLets.Base
-                                                          (#(ident.fst)%expr @
-                                                           ($v1)%expr,
-                                                          #(ident.snd)%expr @
-                                                          ($v1)%expr)%expr_pat)
-                                               | None =>
-                                                   UnderLets.Base
-                                                     (#(ident.Z_add_with_get_carry)%expr @
-                                                      x @ x0 @ x1 @ x2)%expr_pat
-                                               end)
-                                        | (s0 -> d0)%ptype =>
-                                            fun
-                                              _ : Compile.value' false s0 ->
-                                                  Compile.value' true d0 =>
-                                            UnderLets.Base
-                                              (#(ident.Z_add_with_get_carry)%expr @
-                                               x @ x0 @ x1 @ x2)%expr_pat
-                                        end (Compile.reflect x3)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s0 -> d0)%ptype =>
-                                fun
-                                  _ : Compile.value' false s0 ->
-                                      Compile.value' true d0 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args0 <=? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_with_get_borrow)%expr @
-                                           x @ x' v @ x2 @
-                                           ##((- args0)%Z)%expr)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s0 -> d0)%ptype =>
-                                fun
-                                  _ : Compile.value' false s0 ->
-                                      Compile.value' true d0 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        end
-                    | ($_)%expr =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v0 @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | @expr.Abs _ _ _ _ _ _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | @expr.App _ _ _ s0 _ #(idc1)%expr_pat x4 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       match
-                                         s0 as t3
-                                         return
-                                           (Compile.value' false t3 ->
-                                            UnderLets.UnderLets base.type
-                                              ident var
-                                              (defaults.expr
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype)))
-                                       with
-                                       | type.base t3 =>
-                                           fun
-                                             v0 : defaults.expr
-                                                    (type.base t3) =>
-                                           base.try_make_transport_cps
-                                             (fun t4 : base.type =>
-                                              defaults.expr (type.base t4))
-                                             t3 base.type.Z
-                                             (UnderLets.UnderLets base.type
-                                                ident var
-                                                (defaults.expr
-                                                   (type.base
-                                                      (base.type.Z *
-                                                       base.type.Z)%etype)))
-                                             (fun
-                                                a0 : option
-                                                       (defaults.expr
-                                                          (type.base t3) ->
-                                                        defaults.expr
-                                                          (type.base
-                                                             base.type.Z)) =>
-                                              match a0 with
-                                              | Some x'0 =>
-                                                  UnderLets.UnderLet
-                                                    (#(ident.Z_sub_with_get_borrow)%expr @
-                                                     x @ x' v @ x1 @ 
-                                                     x'0 v0)%expr_pat
-                                                    (fun
-                                                       v1 : var
-                                                              (type.base
-                                                                 (base.type.Z *
-                                                                  base.type.Z)%etype)
-                                                     =>
-                                                     UnderLets.Base
-                                                       (#(ident.fst)%expr @
-                                                        ($v1)%expr,
-                                                       (-
-                                                        (#(ident.snd)%expr @
-                                                         $v1)%expr_pat)%expr)%expr_pat)
-                                              | None =>
-                                                  UnderLets.Base
-                                                    (#(ident.Z_add_with_get_carry)%expr @
-                                                     x @ x0 @ x1 @ x2)%expr_pat
-                                              end)
-                                       | (s1 -> d1)%ptype =>
-                                           fun
-                                             _ : Compile.value' false s1 ->
-                                                 Compile.value' true d1 =>
-                                           UnderLets.Base
-                                             (#(ident.Z_add_with_get_carry)%expr @
-                                              x @ x0 @ x1 @ x2)%expr_pat
-                                       end (Compile.reflect x4)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s1 -> d1)%ptype =>
-                                fun
-                                  _ : Compile.value' false s1 ->
-                                      Compile.value' true d1 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args0 <=? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_with_get_borrow)%expr @
-                                           x @ x' v @ x2 @
-                                           ##((- args0)%Z)%expr)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s1 -> d1)%ptype =>
-                                fun
-                                  _ : Compile.value' false s1 ->
-                                      Compile.value' true d1 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        end
-                    | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v0 @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s0 _ (_ @ _)%expr_pat _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | @expr.LetIn _ _ _ _ _ _ _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x2 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    end
-                | None =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args0 <=? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_with_get_borrow)%expr @
-                                           x @ x' v @ x1 @
-                                           ##((- args0)%Z)%expr)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s0 -> d0)%ptype =>
-                                fun
-                                  _ : Compile.value' false s0 ->
-                                      Compile.value' true d0 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s0 _ #(idc1)%expr_pat x4 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       match
-                                         s0 as t3
-                                         return
-                                           (Compile.value' false t3 ->
-                                            UnderLets.UnderLets base.type
-                                              ident var
-                                              (defaults.expr
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype)))
-                                       with
-                                       | type.base t3 =>
-                                           fun
-                                             v0 : defaults.expr
-                                                    (type.base t3) =>
-                                           base.try_make_transport_cps
-                                             (fun t4 : base.type =>
-                                              defaults.expr (type.base t4))
-                                             t3 base.type.Z
-                                             (UnderLets.UnderLets base.type
-                                                ident var
-                                                (defaults.expr
-                                                   (type.base
-                                                      (base.type.Z *
-                                                       base.type.Z)%etype)))
-                                             (fun
-                                                a0 : option
-                                                       (defaults.expr
-                                                          (type.base t3) ->
-                                                        defaults.expr
-                                                          (type.base
-                                                             base.type.Z)) =>
-                                              match a0 with
-                                              | Some x'0 =>
-                                                  UnderLets.UnderLet
-                                                    (#(ident.Z_sub_with_get_borrow)%expr @
-                                                     x @ x' v @ x1 @ 
-                                                     x'0 v0)%expr_pat
-                                                    (fun
-                                                       v1 : var
-                                                              (type.base
-                                                                 (base.type.Z *
-                                                                  base.type.Z)%etype)
-                                                     =>
-                                                     UnderLets.Base
-                                                       (#(ident.fst)%expr @
-                                                        ($v1)%expr,
-                                                       (-
-                                                        (#(ident.snd)%expr @
-                                                         $v1)%expr_pat)%expr)%expr_pat)
-                                              | None =>
-                                                  UnderLets.Base
-                                                    (#(ident.Z_add_with_get_carry)%expr @
-                                                     x @ x0 @ x1 @ x2)%expr_pat
-                                              end)
-                                       | (s1 -> d1)%ptype =>
-                                           fun
-                                             _ : Compile.value' false s1 ->
-                                                 Compile.value' true d1 =>
-                                           UnderLets.Base
-                                             (#(ident.Z_add_with_get_carry)%expr @
-                                              x @ x0 @ x1 @ x2)%expr_pat
-                                       end (Compile.reflect x4)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s1 -> d1)%ptype =>
-                                fun
-                                  _ : Compile.value' false s1 ->
-                                      Compile.value' true d1 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _
-                      _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                end
-            | ($_)%expr =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v0 @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x4 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s0 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v1 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t4 : base.type =>
-                                          defaults.expr (type.base t4)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v0 @ x1 @ x'0 v1)%expr_pat
-                                                (fun
-                                                   v2 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v2)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v2)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s1 -> d1)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s1 ->
-                                             Compile.value' true d1 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x4)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | @expr.Abs _ _ _ _ _ _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ #(idc0)%expr_pat x4 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s1 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v @ x1 @ x'0 v0)%expr_pat
-                                                (fun
-                                                   v1 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v1)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s2 -> d2)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s2 ->
-                                             Compile.value' true d2 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x4)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
+                                                              =>
+                                                              UnderLets.Base
+                                                                (#(ident.fst)%expr @
+                                                                 ($v1)%expr,
+                                                                (-
+                                                                 (#(ident.snd)%expr @
+                                                                  $v1)%expr_pat)%expr)%expr_pat)
+                                                       | None => default
+                                                       end)
+                                                | (s1 -> d1)%ptype =>
+                                                    fun
+                                                      _ : Compile.value'
+                                                            false s1 ->
+                                                          Compile.value' true
+                                                            d1 => default
+                                                end (Compile.reflect x4)
+                                            | None => default
+                                            end)
+                                     | (s1 -> d1)%ptype =>
+                                         fun
+                                           _ : Compile.value' false s1 ->
+                                               Compile.value' true d1 =>
+                                         default
+                                     end (Compile.reflect x3)
+                                 | None => default
+                                 end
+                             | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _
+                               _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
+                               _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _
+                               _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
+                                 default
+                             | _ => default1 tt
+                             end in
+            match x1 with
             | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x4 =>
                 match
                   match idc0 with
@@ -14629,2041 +4914,39 @@ match idc in (ident t) return (Compile.value' true t) with
                                                 ($v1)%expr,
                                                (-
                                                 (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                      | None =>
-                                          UnderLets.Base
-                                            (#(ident.Z_add_with_get_carry)%expr @
-                                             x @ x0 @ x1 @ x2)%expr_pat
+                                      | None => default
                                       end)
                                | (s1 -> d1)%ptype =>
                                    fun
                                      _ : Compile.value' false s1 ->
-                                         Compile.value' true d1 =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
+                                         Compile.value' true d1 => default
                                end (Compile.reflect x4)
-                           | None =>
-                               UnderLets.Base
-                                 (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                  x1 @ x2)%expr_pat
+                           | None => default
                            end)
                     | (s1 -> d1)%ptype =>
                         fun
                           _ : Compile.value' false s1 ->
-                              Compile.value' true d1 =>
-                        UnderLets.Base
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
+                              Compile.value' true d1 => default
                     end (Compile.reflect x3)
-                | None =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       if args0 <=? 0
-                                       then
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_sub_with_get_borrow)%expr @
-                                           x @ x' v @ x1 @
-                                           ##((- args0)%Z)%expr)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             (-
-                                              (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                       else
-                                        UnderLets.UnderLet
-                                          (#(ident.Z_add_with_get_carry)%expr @
-                                           x @ x0 @ x1 @ x2)%expr_pat
-                                          (fun
-                                             v0 : var
-                                                    (type.base
-                                                       (base.type.Z *
-                                                        base.type.Z)%etype)
-                                           =>
-                                           UnderLets.Base
-                                             (#(ident.fst)%expr @ ($v0)%expr,
-                                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s1 -> d1)%ptype =>
-                                fun
-                                  _ : Compile.value' false s1 ->
-                                      Compile.value' true d1 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s1 _ #(idc1)%expr_pat x5 =>
-                        match
-                          match idc1 with
-                          | ident.Z_opp => Some tt
-                          | _ => None
-                          end
-                        with
-                        | Some _ =>
-                            match
-                              s as t2
-                              return
-                                (Compile.value' false t2 ->
-                                 UnderLets.UnderLets base.type ident var
-                                   (defaults.expr
-                                      (type.base
-                                         (base.type.Z * base.type.Z)%etype)))
-                            with
-                            | type.base t2 =>
-                                fun v : defaults.expr (type.base t2) =>
-                                base.try_make_transport_cps
-                                  (fun t3 : base.type =>
-                                   defaults.expr (type.base t3)) t2
-                                  base.type.Z
-                                  (UnderLets.UnderLets base.type ident var
-                                     (defaults.expr
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)))
-                                  (fun
-                                     a : option
-                                           (defaults.expr (type.base t2) ->
-                                            defaults.expr
-                                              (type.base base.type.Z)) =>
-                                   match a with
-                                   | Some x' =>
-                                       match
-                                         s1 as t3
-                                         return
-                                           (Compile.value' false t3 ->
-                                            UnderLets.UnderLets base.type
-                                              ident var
-                                              (defaults.expr
-                                                 (type.base
-                                                    (base.type.Z *
-                                                     base.type.Z)%etype)))
-                                       with
-                                       | type.base t3 =>
-                                           fun
-                                             v0 : defaults.expr
-                                                    (type.base t3) =>
-                                           base.try_make_transport_cps
-                                             (fun t4 : base.type =>
-                                              defaults.expr (type.base t4))
-                                             t3 base.type.Z
-                                             (UnderLets.UnderLets base.type
-                                                ident var
-                                                (defaults.expr
-                                                   (type.base
-                                                      (base.type.Z *
-                                                       base.type.Z)%etype)))
-                                             (fun
-                                                a0 : option
-                                                       (defaults.expr
-                                                          (type.base t3) ->
-                                                        defaults.expr
-                                                          (type.base
-                                                             base.type.Z)) =>
-                                              match a0 with
-                                              | Some x'0 =>
-                                                  UnderLets.UnderLet
-                                                    (#(ident.Z_sub_with_get_borrow)%expr @
-                                                     x @ x' v @ x1 @ 
-                                                     x'0 v0)%expr_pat
-                                                    (fun
-                                                       v1 : var
-                                                              (type.base
-                                                                 (base.type.Z *
-                                                                  base.type.Z)%etype)
-                                                     =>
-                                                     UnderLets.Base
-                                                       (#(ident.fst)%expr @
-                                                        ($v1)%expr,
-                                                       (-
-                                                        (#(ident.snd)%expr @
-                                                         $v1)%expr_pat)%expr)%expr_pat)
-                                              | None =>
-                                                  UnderLets.Base
-                                                    (#(ident.Z_add_with_get_carry)%expr @
-                                                     x @ x0 @ x1 @ x2)%expr_pat
-                                              end)
-                                       | (s2 -> d2)%ptype =>
-                                           fun
-                                             _ : Compile.value' false s2 ->
-                                                 Compile.value' true d2 =>
-                                           UnderLets.Base
-                                             (#(ident.Z_add_with_get_carry)%expr @
-                                              x @ x0 @ x1 @ x2)%expr_pat
-                                       end (Compile.reflect x5)
-                                   | None =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end)
-                            | (s2 -> d2)%ptype =>
-                                fun
-                                  _ : Compile.value' false s2 ->
-                                      Compile.value' true d2 =>
-                                UnderLets.Base
-                                  (#(ident.Z_add_with_get_carry)%expr @ x @
-                                   x0 @ x1 @ x2)%expr_pat
-                            end (Compile.reflect x3)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ |
-                      @expr.App _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _
-                      _ s1 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                end
-            | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v0 @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v1 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v1)%expr,
-                                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ #(idc0)%expr_pat x5 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v0 : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t3 : base.type =>
-                               defaults.expr (type.base t3)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s1 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v1 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t4 : base.type =>
-                                          defaults.expr (type.base t4)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v0 @ x1 @ x'0 v1)%expr_pat
-                                                (fun
-                                                   v2 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v2)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v2)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s2 -> d2)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s2 ->
-                                             Compile.value' true d2 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x5)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s2 _ #(idc0)%expr_pat x5 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s2 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v @ x1 @ x'0 v0)%expr_pat
-                                                (fun
-                                                   v1 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v1)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s3 -> d3)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s3 ->
-                                             Compile.value' true d3 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x5)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s3 -> d3)%ptype =>
-                            fun
-                              _ : Compile.value' false s3 ->
-                                  Compile.value' true d3 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s2 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s2 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s2 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s2 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s0 _ (_ @ _)%expr_pat _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s2 _ #(idc0)%expr_pat x6 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s2 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v @ x1 @ x'0 v0)%expr_pat
-                                                (fun
-                                                   v1 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v1)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s3 -> d3)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s3 ->
-                                             Compile.value' true d3 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x6)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s3 -> d3)%ptype =>
-                            fun
-                              _ : Compile.value' false s3 ->
-                                  Compile.value' true d3 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s2 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s2 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s2 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s2 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ #(idc0)%expr_pat x6 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s1 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v @ x1 @ x'0 v0)%expr_pat
-                                                (fun
-                                                   v1 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v1)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s2 -> d2)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s2 ->
-                                             Compile.value' true d2 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x6)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s2 -> d2)%ptype =>
-                            fun
-                              _ : Compile.value' false s2 ->
-                                  Compile.value' true d2 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s1 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s1 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s1 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s1 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | @expr.LetIn _ _ _ _ _ _ _ =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   if args0 <=? 0
-                                   then
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_sub_with_get_borrow)%expr @
-                                       x @ x' v @ x1 @ ##((- args0)%Z)%expr)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         (-
-                                          (#(ident.snd)%expr @ $v0)%expr_pat)%expr)%expr_pat)
-                                   else
-                                    UnderLets.UnderLet
-                                      (#(ident.Z_add_with_get_carry)%expr @ x @
-                                       x0 @ x1 @ x2)%expr_pat
-                                      (fun
-                                         v0 : var
-                                                (type.base
-                                                   (base.type.Z * base.type.Z)%etype)
-                                       =>
-                                       UnderLets.Base
-                                         (#(ident.fst)%expr @ ($v0)%expr,
-                                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s0 -> d0)%ptype =>
-                            fun
-                              _ : Compile.value' false s0 ->
-                                  Compile.value' true d0 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ #(idc0)%expr_pat x5 =>
-                    match
-                      match idc0 with
-                      | ident.Z_opp => Some tt
-                      | _ => None
-                      end
-                    with
-                    | Some _ =>
-                        match
-                          s as t2
-                          return
-                            (Compile.value' false t2 ->
-                             UnderLets.UnderLets base.type ident var
-                               (defaults.expr
-                                  (type.base
-                                     (base.type.Z * base.type.Z)%etype)))
-                        with
-                        | type.base t2 =>
-                            fun v : defaults.expr (type.base t2) =>
-                            base.try_make_transport_cps
-                              (fun t1 : base.type =>
-                               defaults.expr (type.base t1)) t2 base.type.Z
-                              (UnderLets.UnderLets base.type ident var
-                                 (defaults.expr
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype)))
-                              (fun
-                                 a : option
-                                       (defaults.expr (type.base t2) ->
-                                        defaults.expr (type.base base.type.Z))
-                               =>
-                               match a with
-                               | Some x' =>
-                                   match
-                                     s0 as t3
-                                     return
-                                       (Compile.value' false t3 ->
-                                        UnderLets.UnderLets base.type ident
-                                          var
-                                          (defaults.expr
-                                             (type.base
-                                                (base.type.Z * base.type.Z)%etype)))
-                                   with
-                                   | type.base t3 =>
-                                       fun v0 : defaults.expr (type.base t3)
-                                       =>
-                                       base.try_make_transport_cps
-                                         (fun t1 : base.type =>
-                                          defaults.expr (type.base t1)) t3
-                                         base.type.Z
-                                         (UnderLets.UnderLets base.type ident
-                                            var
-                                            (defaults.expr
-                                               (type.base
-                                                  (base.type.Z * base.type.Z)%etype)))
-                                         (fun
-                                            a0 : option
-                                                   (defaults.expr
-                                                      (type.base t3) ->
-                                                    defaults.expr
-                                                      (type.base base.type.Z))
-                                          =>
-                                          match a0 with
-                                          | Some x'0 =>
-                                              UnderLets.UnderLet
-                                                (#(ident.Z_sub_with_get_borrow)%expr @
-                                                 x @ x' v @ x1 @ x'0 v0)%expr_pat
-                                                (fun
-                                                   v1 : var
-                                                          (type.base
-                                                             (base.type.Z *
-                                                              base.type.Z)%etype)
-                                                 =>
-                                                 UnderLets.Base
-                                                   (#(ident.fst)%expr @
-                                                    ($v1)%expr,
-                                                   (-
-                                                    (#(ident.snd)%expr @ $v1)%expr_pat)%expr)%expr_pat)
-                                          | None =>
-                                              UnderLets.Base
-                                                (#(ident.Z_add_with_get_carry)%expr @
-                                                 x @ x0 @ x1 @ x2)%expr_pat
-                                          end)
-                                   | (s1 -> d1)%ptype =>
-                                       fun
-                                         _ : Compile.value' false s1 ->
-                                             Compile.value' true d1 =>
-                                       UnderLets.Base
-                                         (#(ident.Z_add_with_get_carry)%expr @
-                                          x @ x0 @ x1 @ x2)%expr_pat
-                                   end (Compile.reflect x5)
-                               | None =>
-                                   UnderLets.Base
-                                     (#(ident.Z_add_with_get_carry)%expr @ x @
-                                      x0 @ x1 @ x2)%expr_pat
-                               end)
-                        | (s1 -> d1)%ptype =>
-                            fun
-                              _ : Compile.value' false s1 ->
-                                  Compile.value' true d1 =>
-                            UnderLets.Base
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                        end (Compile.reflect x3)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | @expr.App _ _ _ s0 _ ($_)%expr _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | @expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App
-                  _ _ _ s0 _ (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
-                  (@expr.LetIn _ _ _ _ _ _ _) _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            end
-        | None =>
-            match x1 with
-            | #(idc0)%expr_pat =>
-                match
-                  match idc0 with
-                  | @ident.Literal t1 v =>
-                      match
-                        t1 as t2 return (base.base_interp t2 -> option Z)
-                      with
-                      | base.type.unit => fun _ : unit => None
-                      | base.type.Z => fun v0 : Z => Some v0
-                      | base.type.bool => fun _ : bool => None
-                      | base.type.nat => fun _ : nat => None
-                      end v
-                  | _ => None
-                  end
-                with
-                | Some args =>
-                    match x2 with
-                    | #(idc1)%expr_pat =>
-                        match
-                          match idc1 with
-                          | @ident.Literal t2 v =>
-                              match
-                                t2 as t3
-                                return (base.base_interp t3 -> option Z)
-                              with
-                              | base.type.unit => fun _ : unit => None
-                              | base.type.Z => fun v0 : Z => Some v0
-                              | base.type.bool => fun _ : bool => None
-                              | base.type.nat => fun _ : nat => None
-                              end v
-                          | _ => None
-                          end
-                        with
-                        | Some args0 =>
-                            if (args =? 0) && (args0 =? 0)
-                            then
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                ##(args)%expr @ ##(args0)%expr)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr, ##(0)%expr)%expr_pat)
-                            else
-                             UnderLets.UnderLet
-                               (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                                x1 @ x2)%expr_pat
-                               (fun
-                                  v : var
-                                        (type.base
-                                           (base.type.Z * base.type.Z)%etype)
-                                =>
-                                UnderLets.Base
-                                  (#(ident.fst)%expr @ ($v)%expr,
-                                  #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        | None =>
-                            UnderLets.UnderLet
-                              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                               x1 @ x2)%expr_pat
-                              (fun
-                                 v : var
-                                       (type.base
-                                          (base.type.Z * base.type.Z)%etype)
-                               =>
-                               UnderLets.Base
-                                 (#(ident.fst)%expr @ ($v)%expr,
-                                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                        end
-                    | ($_)%expr =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | _ =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | None =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | ($_)%expr =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            | _ =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        end
-    | @expr.App _ _ _ s _ ($_)%expr _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t1 v0 =>
-                  match
-                    t1 as t2 return (base.base_interp t2 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v1 : Z => Some v1
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v0
-              | _ => None
-              end
-            with
-            | Some args =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t2 v0 =>
-                          match
-                            t2 as t3 return (base.base_interp t3 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v1 : Z => Some v1
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v0
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if (args =? 0) && (args0 =? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                            ##(args)%expr @ ##(args0)%expr)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr, ##(0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v0 : var
-                                     (type.base
-                                        (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v0)%expr,
-                              #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v0 : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v0)%expr,
-                             #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v1 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v1)%expr,
-                         #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                end
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v0)%expr,
-                     #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v1 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v1)%expr,
-                 #(ident.snd)%expr @ ($v1)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        end
-    | @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-      (_ @ _)%expr_pat _ | @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _)
-      _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if (args =? 0) && (args0 =? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                            ##(args)%expr @ ##(args0)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr, ##(0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                end
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-            end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-        end
-    | _ =>
-        match x1 with
-        | #(idc)%expr_pat =>
-            match
-              match idc with
-              | @ident.Literal t0 v =>
-                  match
-                    t0 as t1 return (base.base_interp t1 -> option Z)
-                  with
-                  | base.type.unit => fun _ : unit => None
-                  | base.type.Z => fun v0 : Z => Some v0
-                  | base.type.bool => fun _ : bool => None
-                  | base.type.nat => fun _ : nat => None
-                  end v
-              | _ => None
-              end
-            with
-            | Some args =>
-                match x2 with
-                | #(idc0)%expr_pat =>
-                    match
-                      match idc0 with
-                      | @ident.Literal t1 v =>
-                          match
-                            t1 as t2 return (base.base_interp t2 -> option Z)
-                          with
-                          | base.type.unit => fun _ : unit => None
-                          | base.type.Z => fun v0 : Z => Some v0
-                          | base.type.bool => fun _ : bool => None
-                          | base.type.nat => fun _ : nat => None
-                          end v
-                      | _ => None
-                      end
-                    with
-                    | Some args0 =>
-                        if (args =? 0) && (args0 =? 0)
-                        then
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @
-                            ##(args)%expr @ ##(args0)%expr)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr, ##(0)%expr)%expr_pat)
-                        else
-                         UnderLets.UnderLet
-                           (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                            x2)%expr_pat
-                           (fun
-                              v : var
-                                    (type.base
-                                       (base.type.Z * base.type.Z)%etype) =>
-                            UnderLets.Base
-                              (#(ident.fst)%expr @ ($v)%expr,
-                              #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    | None =>
-                        UnderLets.UnderLet
-                          (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @
-                           x2)%expr_pat
-                          (fun
-                             v : var
-                                   (type.base
-                                      (base.type.Z * base.type.Z)%etype) =>
-                           UnderLets.Base
-                             (#(ident.fst)%expr @ ($v)%expr,
-                             #(ident.snd)%expr @ ($v)%expr)%expr_pat)
-                    end
-                | ($_)%expr =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v0 : var
-                                (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v0)%expr,
-                         #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-                | _ =>
-                    UnderLets.UnderLet
-                      (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                      (fun
-                         v : var
-                               (type.base (base.type.Z * base.type.Z)%etype)
-                       =>
-                       UnderLets.Base
-                         (#(ident.fst)%expr @ ($v)%expr,
-                         #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+                | None => default
                 end
-            | None =>
-                UnderLets.UnderLet
-                  (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-                  (fun v : var (type.base (base.type.Z * base.type.Z)%etype)
-                   =>
-                   UnderLets.Base
-                     (#(ident.fst)%expr @ ($v)%expr,
-                     #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+            | @expr.App _ _ _ s0 _ ($_)%expr _ | @expr.App _ _ _ s0 _
+              (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s0 _
+              (_ @ _)%expr_pat _ | @expr.App _ _ _ s0 _
+              (@expr.LetIn _ _ _ _ _ _ _) _ => default
+            | _ => default1 tt
             end
-        | ($_)%expr =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v0 : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v0)%expr,
-                 #(ident.snd)%expr @ ($v0)%expr)%expr_pat)
-        | _ =>
-            UnderLets.UnderLet
-              (#(ident.Z_add_with_get_carry)%expr @ x @ x0 @ x1 @ x2)%expr_pat
-              (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
-               UnderLets.Base
-                 (#(ident.fst)%expr @ ($v)%expr,
-                 #(ident.snd)%expr @ ($v)%expr)%expr_pat)
+        | None => default
         end
+    | @expr.App _ _ _ s _ ($_)%expr _ | @expr.App _ _ _ s _
+      (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _ (_ @ _)%expr_pat _ |
+      @expr.App _ _ _ s _ (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default0 tt
     end
 | ident.Z_sub_get_borrow =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
+    llet _ := UnderLets.Base
+                (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x1)%expr_pat in
     UnderLets.UnderLet
       (#(ident.Z_sub_get_borrow)%expr @ x @ x0 @ x1)%expr_pat
       (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
@@ -16671,6 +4954,8 @@ match idc in (ident t) return (Compile.value' true t) with
          (#(ident.fst)%expr @ ($v)%expr, #(ident.snd)%expr @ ($v)%expr)%expr_pat)
 | ident.Z_sub_with_get_borrow =>
     fun x x0 x1 x2 : defaults.expr (type.base base.type.Z) =>
+    llet _ := UnderLets.Base
+                (#(ident.Z_sub_with_get_borrow)%expr @ x @ x0 @ x1 @ x2)%expr_pat in
     UnderLets.UnderLet
       (#(ident.Z_sub_with_get_borrow)%expr @ x @ x0 @ x1 @ x2)%expr_pat
       (fun v : var (type.base (base.type.Z * base.type.Z)%etype) =>
@@ -16678,21 +4963,30 @@ match idc in (ident t) return (Compile.value' true t) with
          (#(ident.fst)%expr @ ($v)%expr, #(ident.snd)%expr @ ($v)%expr)%expr_pat)
 | ident.Z_zselect =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_zselect)%expr @ x @ x0 @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.Z_zselect)%expr @ x @ x0 @ x1)%expr_pat in
+    default
 | ident.Z_add_modulo =>
     fun x x0 x1 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_add_modulo)%expr @ x @ x0 @ x1)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.Z_add_modulo)%expr @ x @ x0 @ x1)%expr_pat in
+    default
 | ident.Z_rshi =>
     fun x x0 x1 x2 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_rshi)%expr @ x @ x0 @ x1 @ x2)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.Z_rshi)%expr @ x @ x0 @ x1 @ x2)%expr_pat in
+    default
 | ident.Z_cc_m =>
     fun x x0 : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_cc_m)%expr @ x @ x0)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_cc_m)%expr @ x @ x0)%expr_pat in
+    default
 | ident.Z_cast range =>
     fun x : defaults.expr (type.base base.type.Z) =>
-    UnderLets.Base (#(ident.Z_cast range)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.Z_cast range)%expr @ x)%expr_pat in
+    default
 | ident.Z_cast2 range =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
+    llet default := UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat in
     match x with
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ #(idc)%expr_pat x1) x0 =>
         match
@@ -16755,88 +5049,103 @@ match idc in (ident t) return (Compile.value' true t) with
                                             #(ident.Z_cast (snd range))%expr @
                                             ($(x'0 v0))%expr)%expr_pat;
                                    UnderLets.Base (id (id fv)))%under_lets
-                              | None =>
-                                  UnderLets.Base
-                                    (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+                              | None => default
                               end)
                        | (s1 -> d1)%ptype =>
                            fun
                              _ : Compile.value' false s1 ->
-                                 Compile.value' true d1 =>
-                           UnderLets.Base
-                             (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+                                 Compile.value' true d1 => default
                        end (Compile.reflect x0)
-                   | None =>
-                       UnderLets.Base
-                         (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+                   | None => default
                    end)
             | (s1 -> d1)%ptype =>
                 fun _ : Compile.value' false s1 -> Compile.value' true d1 =>
-                UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+                default
             end (Compile.reflect x1)
-        | None => UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+        | None => default
         end
     | @expr.App _ _ _ s _ (@expr.App _ _ _ s0 _ ($_)%expr _) _ | @expr.App _
       _ _ s _ (@expr.App _ _ _ s0 _ (@expr.Abs _ _ _ _ _ _) _) _ | @expr.App
       _ _ _ s _ (@expr.App _ _ _ s0 _ (_ @ _)%expr_pat _) _ | @expr.App _ _ _
-      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ =>
-        UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+      s _ (@expr.App _ _ _ s0 _ (@expr.LetIn _ _ _ _ _ _ _) _) _ => default
     | @expr.App _ _ _ s _ #(_)%expr_pat _ | @expr.App _ _ _ s _ ($_)%expr _ |
       @expr.App _ _ _ s _ (@expr.Abs _ _ _ _ _ _) _ | @expr.App _ _ _ s _
-      (@expr.LetIn _ _ _ _ _ _ _) _ =>
-        UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat
-    | _ => UnderLets.Base (#(ident.Z_cast2 range)%expr @ x)%expr_pat
+      (@expr.LetIn _ _ _ _ _ _ _) _ => default
+    | _ => default
     end
 | ident.fancy_add log2wordmax imm =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_add log2wordmax imm)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_add log2wordmax imm)%expr @ x)%expr_pat in
+    default
 | ident.fancy_addc log2wordmax imm =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_addc log2wordmax imm)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_addc log2wordmax imm)%expr @ x)%expr_pat in
+    default
 | ident.fancy_sub log2wordmax imm =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_sub log2wordmax imm)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_sub log2wordmax imm)%expr @ x)%expr_pat in
+    default
 | ident.fancy_subb log2wordmax imm =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_subb log2wordmax imm)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_subb log2wordmax imm)%expr @ x)%expr_pat in
+    default
 | ident.fancy_mulll log2wordmax =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_mulll log2wordmax)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_mulll log2wordmax)%expr @ x)%expr_pat in
+    default
 | ident.fancy_mullh log2wordmax =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_mullh log2wordmax)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_mullh log2wordmax)%expr @ x)%expr_pat in
+    default
 | ident.fancy_mulhl log2wordmax =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_mulhl log2wordmax)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_mulhl log2wordmax)%expr @ x)%expr_pat in
+    default
 | ident.fancy_mulhh log2wordmax =>
     fun x : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_mulhh log2wordmax)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_mulhh log2wordmax)%expr @ x)%expr_pat in
+    default
 | ident.fancy_rshi log2wordmax x =>
     fun x0 : defaults.expr (type.base (base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_rshi log2wordmax x)%expr @ x0)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_rshi log2wordmax x)%expr @ x0)%expr_pat in
+    default
 | ident.fancy_selc =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_selc)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.fancy_selc)%expr @ x)%expr_pat in
+    default
 | ident.fancy_selm log2wordmax =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_selm log2wordmax)%expr @ x)%expr_pat
+    llet default := UnderLets.Base
+                      (#(ident.fancy_selm log2wordmax)%expr @ x)%expr_pat in
+    default
 | ident.fancy_sell =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_sell)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.fancy_sell)%expr @ x)%expr_pat in
+    default
 | ident.fancy_addm =>
     fun
       x : defaults.expr
             (type.base (base.type.Z * base.type.Z * base.type.Z)%etype) =>
-    UnderLets.Base (#(ident.fancy_addm)%expr @ x)%expr_pat
+    llet default := UnderLets.Base (#(ident.fancy_addm)%expr @ x)%expr_pat in
+    default
 end
      : Compile.value' true t