From 1e421b2ecb13f9576ffcfa1078dc9fd7899d8a8a Mon Sep 17 00:00:00 2001
From: Leonardo de Moura <leonardo@microsoft.com>
Date: Tue, 17 Dec 2019 15:24:50 -0800
Subject: [PATCH] chore: update stage0

---
 stage0/src/Init/Lean/Elab/Term.lean     |   50 +-
 stage0/src/Init/Lean/Parser/Parser.lean |   15 +
 stage0/src/Init/Lean/Parser/Term.lean   |    4 +-
 stage0/stdlib/Init/Lean/Elab/Term.c     | 3949 +++++++++++++++++++----
 stage0/stdlib/Init/Lean/Parser/Parser.c |  130 +
 stage0/stdlib/Init/Lean/Parser/Term.c   |  804 +++--
 6 files changed, 4117 insertions(+), 835 deletions(-)

diff --git a/stage0/src/Init/Lean/Elab/Term.lean b/stage0/src/Init/Lean/Elab/Term.lean
index 77da105100..668cf712a8 100644
--- a/stage0/src/Init/Lean/Elab/Term.lean
+++ b/stage0/src/Init/Lean/Elab/Term.lean
@@ -496,7 +496,10 @@ partial def getFunBinderIdsAux? : Bool → Syntax → Array Syntax → TermElabM
     pure (some (acc.push (args.getA 0)))
   else
     pure none
-| _, _, _ => pure none
+| _, n@(Syntax.node `Lean.Parser.Term.hole _), acc => do
+  ident ← mkFreshAnonymousIdent n;
+  pure (some (acc.push ident))
+| idOnly, stx, acc => pure none
 
 def getFunBinderIds? (stx : Syntax) : TermElabM (Option (Array Syntax)) :=
 getFunBinderIdsAux? false stx #[]
@@ -593,46 +596,21 @@ match stx? with
 | some stx' => withMacroExpansion stx (elabTerm stx' expectedType?)
 | none      => elabTerm stx expectedType?
 
-@[builtinTermElab paren] def elabParen : TermElab :=
- fun stx expectedType? =>
-  -- `(` (termParser >> parenSpecial)? `)`
-  let ref := stx.val;
-  let body := stx.getArg 1;
-  if body.isNone then
-    pure $ Lean.mkConst `Unit.unit
-  else
-    let term := body.getArg 0;
-    let special := body.getArg 1;
-    if special.isNone then do
-      elabCDot term expectedType?
-    else
-      let special := special.getArg 0;
-      if special.getKind == `Lean.Parser.Term.typeAscription then do
-        type ← elabType (special.getArg 1);
-        e ← elabCDot term expectedType?;
-        eType ← inferType ref e;
-        ensureHasType ref type eType e
-      else if special.getKind == `Lean.Parser.Term.tupleTail then do
-        -- tupleTail := `,` >> sepBy1 term `,`
-        let terms := (special.getArg 1).foldSepArgs (fun e (elems : Array Syntax) => elems.push e) #[term];
-        pairs ← mkPairs terms;
-        withMacroExpansion stx.val (elabTerm pairs expectedType?)
-      else
-        throwError ref "unexpected parentheses notation"
-
-/-
 @[builtinTermElab paren] def elabParen : TermElab :=
 fun stx expectedType? =>
-  match_syntax stx.val with
+  let ref := stx.val;
+  match_syntax ref with
   | `(())             => pure $ Lean.mkConst `Unit.unit
-  | `((%%e : %%type)) => do type ← elabType type; elabTerm e type
-  | `((%%e))          => elabTerm e expectedType?
-  | `((%%e, %%es))    => do
-
-    pairs ← mkPairs elems;
+  | `((%%e : %%type)) => do
+    type ← elabType type;
+    e ← elabCDot e expectedType?;
+    eType ← inferType ref e;
+    ensureHasType ref type eType e
+  | `((%%e))          => elabCDot e expectedType?
+  | `((%%e, %%es*))   => do
+    pairs ← mkPairs (#[e] ++ es.getEvenElems);
     withMacroExpansion stx.val (elabTerm pairs expectedType?)
   | _ => throwError stx.val "unexpected parentheses notation"
--/
 
 @[builtinTermElab «listLit»] def elabListLit : TermElab :=
 fun stx expectedType? => do
diff --git a/stage0/src/Init/Lean/Parser/Parser.lean b/stage0/src/Init/Lean/Parser/Parser.lean
index 7c3f08ff1d..915dc509a6 100644
--- a/stage0/src/Init/Lean/Parser/Parser.lean
+++ b/stage0/src/Init/Lean/Parser/Parser.lean
@@ -1600,3 +1600,18 @@ end
 
 end Syntax
 end Lean
+
+section
+variables {β : Type} {m : Type → Type} [Monad m]
+open Lean
+open Lean.Syntax
+
+@[inline] def Array.foldSepByM (args : Array Syntax) (f : Syntax → β → m β) (b : β) : m β :=
+foldArgsAuxM 2 args f 0 b
+
+@[inline] def Array.foldSepBy (args : Array Syntax) (f : Syntax → β → β) (b : β) : β :=
+Id.run $ args.foldSepByM f b
+
+@[inline] def Array.getEvenElems (args : Array Syntax) : Array Syntax :=
+args.foldSepBy (fun a as => Array.push as a) #[]
+end
diff --git a/stage0/src/Init/Lean/Parser/Term.lean b/stage0/src/Init/Lean/Parser/Term.lean
index 56d3719167..3f223d2f62 100644
--- a/stage0/src/Init/Lean/Parser/Term.lean
+++ b/stage0/src/Init/Lean/Parser/Term.lean
@@ -44,7 +44,7 @@ pushLeading >> symbol sym lbp >> termParser lbp
 -- forms can also be used with an appended `*` to turn them into an
 -- antiquotation "splice".
 def mkAntiquot (name : Option String) : Parser leading :=
-leadingNode `Lean.Parser.Term.antiquot $ symbol "%%" appPrec >> termParser appPrec >> (
+leadingNode `Lean.Parser.Term.antiquot $ symbol "$" 1 >> checkNoWsBefore "no space before" >> termParser appPrec >> (
   match name with
   | some name => let sym := ":" ++ name; checkNoWsBefore ("no space before '" ++ sym ++ "'") >> sym
   -- make sure to generate as many children (1) as in the first case to keep arity constant
@@ -140,7 +140,7 @@ def checkIsSort := checkLeading (fun leading => leading.isOfKind `Lean.Parser.Te
 @[builtinTermParser] def arrow   := tparser! unicodeInfixR " → " " -> " 25
 @[builtinTermParser] def arrayRef := tparser! pushLeading >> symbolNoWs "[" (appPrec+1) >> termParser >>"]"
 
-@[builtinTermParser] def dollar := tparser! infixR " $ " 1
+@[builtinTermParser] def dollar := tparser! try (pushLeading >> symbol " $ " 1 >> checkWsBefore "space expected") >> termParser 0
 @[builtinTermParser] def fcomp  := tparser! infixR " ∘ " 90
 
 @[builtinTermParser] def prod  := tparser! infixR " × " 35
diff --git a/stage0/stdlib/Init/Lean/Elab/Term.c b/stage0/stdlib/Init/Lean/Elab/Term.c
index 01a3d75b92..b9a4e23316 100644
--- a/stage0/stdlib/Init/Lean/Elab/Term.c
+++ b/stage0/stdlib/Init/Lean/Elab/Term.c
@@ -881,6 +881,7 @@ lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabStr(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Term_12__elabBindersAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabApp___closed__2;
 lean_object* l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_Term_30__toMessageData___spec__1(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_tracer___closed__1;
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabHole___closed__3;
@@ -26767,184 +26768,282 @@ x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
 if (lean_obj_tag(x_10) == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_11 = lean_ctor_get(x_2, 1);
-lean_inc(x_11);
-lean_dec(x_2);
-x_12 = lean_ctor_get(x_6, 1);
-lean_inc(x_12);
-lean_dec(x_6);
-x_13 = lean_ctor_get(x_7, 1);
-lean_inc(x_13);
-lean_dec(x_7);
-x_14 = lean_ctor_get(x_8, 1);
-lean_inc(x_14);
-lean_dec(x_8);
-x_15 = lean_ctor_get(x_9, 1);
-lean_inc(x_15);
-lean_dec(x_9);
-x_16 = l_Lean_nameToExprAux___main___closed__1;
-x_17 = lean_string_dec_eq(x_15, x_16);
-lean_dec(x_15);
+uint8_t x_11; 
+x_11 = !lean_is_exclusive(x_2);
+if (x_11 == 0)
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_2, 1);
+x_13 = lean_ctor_get(x_2, 0);
+lean_dec(x_13);
+x_14 = !lean_is_exclusive(x_6);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_6, 1);
+x_16 = lean_ctor_get(x_6, 0);
+lean_dec(x_16);
+x_17 = !lean_is_exclusive(x_7);
 if (x_17 == 0)
 {
-lean_object* x_18; lean_object* x_19; 
-lean_dec(x_14);
-lean_dec(x_13);
+lean_object* x_18; lean_object* x_19; uint8_t x_20; 
+x_18 = lean_ctor_get(x_7, 1);
+x_19 = lean_ctor_get(x_7, 0);
+lean_dec(x_19);
+x_20 = !lean_is_exclusive(x_8);
+if (x_20 == 0)
+{
+lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+x_21 = lean_ctor_get(x_8, 1);
+x_22 = lean_ctor_get(x_8, 0);
+lean_dec(x_22);
+x_23 = !lean_is_exclusive(x_9);
+if (x_23 == 0)
+{
+lean_object* x_24; size_t x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_24 = lean_ctor_get(x_9, 1);
+x_25 = lean_ctor_get_usize(x_9, 2);
+x_26 = lean_ctor_get(x_9, 0);
+lean_dec(x_26);
+x_27 = l_Lean_nameToExprAux___main___closed__1;
+x_28 = lean_string_dec_eq(x_24, x_27);
+lean_dec(x_24);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_dec(x_21);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
 lean_dec(x_12);
-lean_dec(x_11);
 lean_dec(x_3);
-x_18 = lean_box(0);
-x_19 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_19, 1, x_5);
-return x_19;
+x_29 = lean_box(0);
+x_30 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_5);
+return x_30;
 }
 else
 {
-lean_object* x_20; uint8_t x_21; 
-x_20 = l_Lean_Syntax_formatStx___main___closed__5;
-x_21 = lean_string_dec_eq(x_14, x_20);
-lean_dec(x_14);
-if (x_21 == 0)
+lean_object* x_31; uint8_t x_32; 
+x_31 = l_Lean_Syntax_formatStx___main___closed__5;
+x_32 = lean_string_dec_eq(x_21, x_31);
+lean_dec(x_21);
+if (x_32 == 0)
 {
-lean_object* x_22; lean_object* x_23; 
-lean_dec(x_13);
+lean_object* x_33; lean_object* x_34; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
 lean_dec(x_12);
-lean_dec(x_11);
 lean_dec(x_3);
-x_22 = lean_box(0);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_5);
-return x_23;
+x_33 = lean_box(0);
+x_34 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_5);
+return x_34;
 }
 else
 {
-lean_object* x_24; uint8_t x_25; 
-x_24 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
-x_25 = lean_string_dec_eq(x_13, x_24);
-lean_dec(x_13);
-if (x_25 == 0)
+lean_object* x_35; uint8_t x_36; 
+x_35 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_36 = lean_string_dec_eq(x_18, x_35);
+lean_dec(x_18);
+if (x_36 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
+lean_object* x_37; lean_object* x_38; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
 lean_dec(x_12);
-lean_dec(x_11);
 lean_dec(x_3);
-x_26 = lean_box(0);
-x_27 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_27, 0, x_26);
-lean_ctor_set(x_27, 1, x_5);
-return x_27;
+x_37 = lean_box(0);
+x_38 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_38, 0, x_37);
+lean_ctor_set(x_38, 1, x_5);
+return x_38;
 }
 else
 {
-lean_object* x_28; uint8_t x_29; 
-x_28 = l_Lean_Parser_Term_app___elambda__1___closed__1;
-x_29 = lean_string_dec_eq(x_12, x_28);
-if (x_29 == 0)
+lean_object* x_39; uint8_t x_40; 
+x_39 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_40 = lean_string_dec_eq(x_15, x_39);
+if (x_40 == 0)
 {
-lean_object* x_30; uint8_t x_31; 
-x_30 = l_Lean_Parser_Term_id___elambda__1___closed__1;
-x_31 = lean_string_dec_eq(x_12, x_30);
+lean_object* x_41; uint8_t x_42; 
+x_41 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_42 = lean_string_dec_eq(x_15, x_41);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_44 = lean_string_dec_eq(x_15, x_43);
+lean_dec(x_15);
+if (x_44 == 0)
+{
+lean_object* x_45; lean_object* x_46; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_free_object(x_2);
 lean_dec(x_12);
-if (x_31 == 0)
-{
-lean_object* x_32; lean_object* x_33; 
-lean_dec(x_11);
 lean_dec(x_3);
-x_32 = lean_box(0);
-x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_5);
-return x_33;
+x_45 = lean_box(0);
+x_46 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_46, 0, x_45);
+lean_ctor_set(x_46, 1, x_5);
+return x_46;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_34 = lean_unsigned_to_nat(1u);
-x_35 = lean_box(0);
-x_36 = l_Array_getD___rarg(x_11, x_34, x_35);
-x_37 = l_Lean_Syntax_isNone(x_36);
-lean_dec(x_36);
-if (x_37 == 0)
+lean_object* x_47; uint8_t x_48; 
+lean_ctor_set(x_9, 1, x_27);
+lean_ctor_set(x_8, 1, x_31);
+lean_ctor_set_usize(x_8, 2, x_25);
+lean_ctor_set(x_7, 1, x_35);
+lean_ctor_set_usize(x_7, 2, x_25);
+lean_ctor_set(x_6, 1, x_43);
+lean_ctor_set_usize(x_6, 2, x_25);
+x_47 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_48 = !lean_is_exclusive(x_47);
+if (x_48 == 0)
 {
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_11);
-lean_dec(x_3);
-x_38 = lean_box(0);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_5);
-return x_39;
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_49 = lean_ctor_get(x_47, 0);
+x_50 = lean_array_push(x_3, x_49);
+x_51 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_51, 0, x_50);
+lean_ctor_set(x_47, 0, x_51);
+return x_47;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_40 = lean_unsigned_to_nat(0u);
-x_41 = l_Array_getD___rarg(x_11, x_40, x_35);
-lean_dec(x_11);
-x_42 = lean_array_push(x_3, x_41);
-x_43 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_43, 0, x_42);
-x_44 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_44, 0, x_43);
-lean_ctor_set(x_44, 1, x_5);
-return x_44;
-}
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_12);
-x_45 = lean_unsigned_to_nat(0u);
-x_46 = lean_box(0);
-x_47 = l_Array_getD___rarg(x_11, x_45, x_46);
-x_48 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_47, x_3, x_4, x_5);
-x_49 = lean_ctor_get(x_48, 0);
-lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
-{
-uint8_t x_50; 
-lean_dec(x_11);
-x_50 = !lean_is_exclusive(x_48);
-if (x_50 == 0)
-{
-lean_object* x_51; 
-x_51 = lean_ctor_get(x_48, 0);
-lean_dec(x_51);
-return x_48;
-}
-else
-{
-lean_object* x_52; lean_object* x_53; 
-x_52 = lean_ctor_get(x_48, 1);
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_52 = lean_ctor_get(x_47, 0);
+x_53 = lean_ctor_get(x_47, 1);
+lean_inc(x_53);
 lean_inc(x_52);
-lean_dec(x_48);
-x_53 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_53, 0, x_49);
-lean_ctor_set(x_53, 1, x_52);
-return x_53;
+lean_dec(x_47);
+x_54 = lean_array_push(x_3, x_52);
+x_55 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_55, 0, x_54);
+x_56 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_53);
+return x_56;
+}
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; 
-x_54 = lean_ctor_get(x_48, 1);
-lean_inc(x_54);
-lean_dec(x_48);
-x_55 = lean_ctor_get(x_49, 0);
-lean_inc(x_55);
-lean_dec(x_49);
-x_56 = lean_unsigned_to_nat(1u);
-x_57 = l_Array_getD___rarg(x_11, x_56, x_46);
-lean_dec(x_11);
-x_58 = 1;
-x_1 = x_58;
-x_2 = x_57;
-x_3 = x_55;
-x_5 = x_54;
+lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_57 = lean_unsigned_to_nat(1u);
+x_58 = lean_box(0);
+x_59 = l_Array_getD___rarg(x_12, x_57, x_58);
+x_60 = l_Lean_Syntax_isNone(x_59);
+lean_dec(x_59);
+if (x_60 == 0)
+{
+lean_object* x_61; lean_object* x_62; 
+lean_dec(x_12);
+lean_dec(x_3);
+x_61 = lean_box(0);
+x_62 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_62, 0, x_61);
+lean_ctor_set(x_62, 1, x_5);
+return x_62;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_63 = lean_unsigned_to_nat(0u);
+x_64 = l_Array_getD___rarg(x_12, x_63, x_58);
+lean_dec(x_12);
+x_65 = lean_array_push(x_3, x_64);
+x_66 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_66, 0, x_65);
+x_67 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_5);
+return x_67;
+}
+}
+}
+else
+{
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+lean_free_object(x_9);
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_68 = lean_unsigned_to_nat(0u);
+x_69 = lean_box(0);
+x_70 = l_Array_getD___rarg(x_12, x_68, x_69);
+x_71 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_70, x_3, x_4, x_5);
+x_72 = lean_ctor_get(x_71, 0);
+lean_inc(x_72);
+if (lean_obj_tag(x_72) == 0)
+{
+uint8_t x_73; 
+lean_dec(x_12);
+x_73 = !lean_is_exclusive(x_71);
+if (x_73 == 0)
+{
+lean_object* x_74; 
+x_74 = lean_ctor_get(x_71, 0);
+lean_dec(x_74);
+return x_71;
+}
+else
+{
+lean_object* x_75; lean_object* x_76; 
+x_75 = lean_ctor_get(x_71, 1);
+lean_inc(x_75);
+lean_dec(x_71);
+x_76 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_76, 0, x_72);
+lean_ctor_set(x_76, 1, x_75);
+return x_76;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; 
+x_77 = lean_ctor_get(x_71, 1);
+lean_inc(x_77);
+lean_dec(x_71);
+x_78 = lean_ctor_get(x_72, 0);
+lean_inc(x_78);
+lean_dec(x_72);
+x_79 = lean_unsigned_to_nat(1u);
+x_80 = l_Array_getD___rarg(x_12, x_79, x_69);
+lean_dec(x_12);
+x_81 = 1;
+x_1 = x_81;
+x_2 = x_80;
+x_3 = x_78;
+x_5 = x_77;
 goto _start;
 }
 }
@@ -26954,7 +27053,1402 @@ goto _start;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; 
+lean_object* x_83; size_t x_84; lean_object* x_85; uint8_t x_86; 
+x_83 = lean_ctor_get(x_9, 1);
+x_84 = lean_ctor_get_usize(x_9, 2);
+lean_inc(x_83);
+lean_dec(x_9);
+x_85 = l_Lean_nameToExprAux___main___closed__1;
+x_86 = lean_string_dec_eq(x_83, x_85);
+lean_dec(x_83);
+if (x_86 == 0)
+{
+lean_object* x_87; lean_object* x_88; 
+lean_free_object(x_8);
+lean_dec(x_21);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_87 = lean_box(0);
+x_88 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_88, 0, x_87);
+lean_ctor_set(x_88, 1, x_5);
+return x_88;
+}
+else
+{
+lean_object* x_89; uint8_t x_90; 
+x_89 = l_Lean_Syntax_formatStx___main___closed__5;
+x_90 = lean_string_dec_eq(x_21, x_89);
+lean_dec(x_21);
+if (x_90 == 0)
+{
+lean_object* x_91; lean_object* x_92; 
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_91 = lean_box(0);
+x_92 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_92, 0, x_91);
+lean_ctor_set(x_92, 1, x_5);
+return x_92;
+}
+else
+{
+lean_object* x_93; uint8_t x_94; 
+x_93 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_94 = lean_string_dec_eq(x_18, x_93);
+lean_dec(x_18);
+if (x_94 == 0)
+{
+lean_object* x_95; lean_object* x_96; 
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_95 = lean_box(0);
+x_96 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_96, 0, x_95);
+lean_ctor_set(x_96, 1, x_5);
+return x_96;
+}
+else
+{
+lean_object* x_97; uint8_t x_98; 
+x_97 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_98 = lean_string_dec_eq(x_15, x_97);
+if (x_98 == 0)
+{
+lean_object* x_99; uint8_t x_100; 
+x_99 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_100 = lean_string_dec_eq(x_15, x_99);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_102 = lean_string_dec_eq(x_15, x_101);
+lean_dec(x_15);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; 
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_103 = lean_box(0);
+x_104 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_104, 0, x_103);
+lean_ctor_set(x_104, 1, x_5);
+return x_104;
+}
+else
+{
+lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+x_105 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_105, 0, x_10);
+lean_ctor_set(x_105, 1, x_85);
+lean_ctor_set_usize(x_105, 2, x_84);
+lean_ctor_set(x_8, 1, x_89);
+lean_ctor_set(x_8, 0, x_105);
+lean_ctor_set_usize(x_8, 2, x_84);
+lean_ctor_set(x_7, 1, x_93);
+lean_ctor_set_usize(x_7, 2, x_84);
+lean_ctor_set(x_6, 1, x_101);
+lean_ctor_set_usize(x_6, 2, x_84);
+x_106 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_107 = lean_ctor_get(x_106, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_106, 1);
+lean_inc(x_108);
+if (lean_is_exclusive(x_106)) {
+ lean_ctor_release(x_106, 0);
+ lean_ctor_release(x_106, 1);
+ x_109 = x_106;
+} else {
+ lean_dec_ref(x_106);
+ x_109 = lean_box(0);
+}
+x_110 = lean_array_push(x_3, x_107);
+x_111 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_111, 0, x_110);
+if (lean_is_scalar(x_109)) {
+ x_112 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_112 = x_109;
+}
+lean_ctor_set(x_112, 0, x_111);
+lean_ctor_set(x_112, 1, x_108);
+return x_112;
+}
+}
+else
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; 
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_113 = lean_unsigned_to_nat(1u);
+x_114 = lean_box(0);
+x_115 = l_Array_getD___rarg(x_12, x_113, x_114);
+x_116 = l_Lean_Syntax_isNone(x_115);
+lean_dec(x_115);
+if (x_116 == 0)
+{
+lean_object* x_117; lean_object* x_118; 
+lean_dec(x_12);
+lean_dec(x_3);
+x_117 = lean_box(0);
+x_118 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_118, 0, x_117);
+lean_ctor_set(x_118, 1, x_5);
+return x_118;
+}
+else
+{
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; 
+x_119 = lean_unsigned_to_nat(0u);
+x_120 = l_Array_getD___rarg(x_12, x_119, x_114);
+lean_dec(x_12);
+x_121 = lean_array_push(x_3, x_120);
+x_122 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_122, 0, x_121);
+x_123 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_123, 0, x_122);
+lean_ctor_set(x_123, 1, x_5);
+return x_123;
+}
+}
+}
+else
+{
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; 
+lean_free_object(x_8);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_124 = lean_unsigned_to_nat(0u);
+x_125 = lean_box(0);
+x_126 = l_Array_getD___rarg(x_12, x_124, x_125);
+x_127 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_126, x_3, x_4, x_5);
+x_128 = lean_ctor_get(x_127, 0);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
+{
+lean_object* x_129; lean_object* x_130; lean_object* x_131; 
+lean_dec(x_12);
+x_129 = lean_ctor_get(x_127, 1);
+lean_inc(x_129);
+if (lean_is_exclusive(x_127)) {
+ lean_ctor_release(x_127, 0);
+ lean_ctor_release(x_127, 1);
+ x_130 = x_127;
+} else {
+ lean_dec_ref(x_127);
+ x_130 = lean_box(0);
+}
+if (lean_is_scalar(x_130)) {
+ x_131 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_131 = x_130;
+}
+lean_ctor_set(x_131, 0, x_128);
+lean_ctor_set(x_131, 1, x_129);
+return x_131;
+}
+else
+{
+lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; 
+x_132 = lean_ctor_get(x_127, 1);
+lean_inc(x_132);
+lean_dec(x_127);
+x_133 = lean_ctor_get(x_128, 0);
+lean_inc(x_133);
+lean_dec(x_128);
+x_134 = lean_unsigned_to_nat(1u);
+x_135 = l_Array_getD___rarg(x_12, x_134, x_125);
+lean_dec(x_12);
+x_136 = 1;
+x_1 = x_136;
+x_2 = x_135;
+x_3 = x_133;
+x_5 = x_132;
+goto _start;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_138; lean_object* x_139; size_t x_140; lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_138 = lean_ctor_get(x_8, 1);
+lean_inc(x_138);
+lean_dec(x_8);
+x_139 = lean_ctor_get(x_9, 1);
+lean_inc(x_139);
+x_140 = lean_ctor_get_usize(x_9, 2);
+if (lean_is_exclusive(x_9)) {
+ lean_ctor_release(x_9, 0);
+ lean_ctor_release(x_9, 1);
+ x_141 = x_9;
+} else {
+ lean_dec_ref(x_9);
+ x_141 = lean_box(0);
+}
+x_142 = l_Lean_nameToExprAux___main___closed__1;
+x_143 = lean_string_dec_eq(x_139, x_142);
+lean_dec(x_139);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; 
+lean_dec(x_141);
+lean_dec(x_138);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_144 = lean_box(0);
+x_145 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_145, 0, x_144);
+lean_ctor_set(x_145, 1, x_5);
+return x_145;
+}
+else
+{
+lean_object* x_146; uint8_t x_147; 
+x_146 = l_Lean_Syntax_formatStx___main___closed__5;
+x_147 = lean_string_dec_eq(x_138, x_146);
+lean_dec(x_138);
+if (x_147 == 0)
+{
+lean_object* x_148; lean_object* x_149; 
+lean_dec(x_141);
+lean_free_object(x_7);
+lean_dec(x_18);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_148 = lean_box(0);
+x_149 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_149, 0, x_148);
+lean_ctor_set(x_149, 1, x_5);
+return x_149;
+}
+else
+{
+lean_object* x_150; uint8_t x_151; 
+x_150 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_151 = lean_string_dec_eq(x_18, x_150);
+lean_dec(x_18);
+if (x_151 == 0)
+{
+lean_object* x_152; lean_object* x_153; 
+lean_dec(x_141);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_152 = lean_box(0);
+x_153 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_153, 0, x_152);
+lean_ctor_set(x_153, 1, x_5);
+return x_153;
+}
+else
+{
+lean_object* x_154; uint8_t x_155; 
+x_154 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_155 = lean_string_dec_eq(x_15, x_154);
+if (x_155 == 0)
+{
+lean_object* x_156; uint8_t x_157; 
+x_156 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_157 = lean_string_dec_eq(x_15, x_156);
+if (x_157 == 0)
+{
+lean_object* x_158; uint8_t x_159; 
+x_158 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_159 = lean_string_dec_eq(x_15, x_158);
+lean_dec(x_15);
+if (x_159 == 0)
+{
+lean_object* x_160; lean_object* x_161; 
+lean_dec(x_141);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_160 = lean_box(0);
+x_161 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_161, 0, x_160);
+lean_ctor_set(x_161, 1, x_5);
+return x_161;
+}
+else
+{
+lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
+if (lean_is_scalar(x_141)) {
+ x_162 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_162 = x_141;
+}
+lean_ctor_set(x_162, 0, x_10);
+lean_ctor_set(x_162, 1, x_142);
+lean_ctor_set_usize(x_162, 2, x_140);
+x_163 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_163, 0, x_162);
+lean_ctor_set(x_163, 1, x_146);
+lean_ctor_set_usize(x_163, 2, x_140);
+lean_ctor_set(x_7, 1, x_150);
+lean_ctor_set(x_7, 0, x_163);
+lean_ctor_set_usize(x_7, 2, x_140);
+lean_ctor_set(x_6, 1, x_158);
+lean_ctor_set_usize(x_6, 2, x_140);
+x_164 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_165 = lean_ctor_get(x_164, 0);
+lean_inc(x_165);
+x_166 = lean_ctor_get(x_164, 1);
+lean_inc(x_166);
+if (lean_is_exclusive(x_164)) {
+ lean_ctor_release(x_164, 0);
+ lean_ctor_release(x_164, 1);
+ x_167 = x_164;
+} else {
+ lean_dec_ref(x_164);
+ x_167 = lean_box(0);
+}
+x_168 = lean_array_push(x_3, x_165);
+x_169 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_169, 0, x_168);
+if (lean_is_scalar(x_167)) {
+ x_170 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_170 = x_167;
+}
+lean_ctor_set(x_170, 0, x_169);
+lean_ctor_set(x_170, 1, x_166);
+return x_170;
+}
+}
+else
+{
+lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; 
+lean_dec(x_141);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_171 = lean_unsigned_to_nat(1u);
+x_172 = lean_box(0);
+x_173 = l_Array_getD___rarg(x_12, x_171, x_172);
+x_174 = l_Lean_Syntax_isNone(x_173);
+lean_dec(x_173);
+if (x_174 == 0)
+{
+lean_object* x_175; lean_object* x_176; 
+lean_dec(x_12);
+lean_dec(x_3);
+x_175 = lean_box(0);
+x_176 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_176, 0, x_175);
+lean_ctor_set(x_176, 1, x_5);
+return x_176;
+}
+else
+{
+lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; 
+x_177 = lean_unsigned_to_nat(0u);
+x_178 = l_Array_getD___rarg(x_12, x_177, x_172);
+lean_dec(x_12);
+x_179 = lean_array_push(x_3, x_178);
+x_180 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_180, 0, x_179);
+x_181 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_181, 0, x_180);
+lean_ctor_set(x_181, 1, x_5);
+return x_181;
+}
+}
+}
+else
+{
+lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
+lean_dec(x_141);
+lean_free_object(x_7);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_182 = lean_unsigned_to_nat(0u);
+x_183 = lean_box(0);
+x_184 = l_Array_getD___rarg(x_12, x_182, x_183);
+x_185 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_184, x_3, x_4, x_5);
+x_186 = lean_ctor_get(x_185, 0);
+lean_inc(x_186);
+if (lean_obj_tag(x_186) == 0)
+{
+lean_object* x_187; lean_object* x_188; lean_object* x_189; 
+lean_dec(x_12);
+x_187 = lean_ctor_get(x_185, 1);
+lean_inc(x_187);
+if (lean_is_exclusive(x_185)) {
+ lean_ctor_release(x_185, 0);
+ lean_ctor_release(x_185, 1);
+ x_188 = x_185;
+} else {
+ lean_dec_ref(x_185);
+ x_188 = lean_box(0);
+}
+if (lean_is_scalar(x_188)) {
+ x_189 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_189 = x_188;
+}
+lean_ctor_set(x_189, 0, x_186);
+lean_ctor_set(x_189, 1, x_187);
+return x_189;
+}
+else
+{
+lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; uint8_t x_194; 
+x_190 = lean_ctor_get(x_185, 1);
+lean_inc(x_190);
+lean_dec(x_185);
+x_191 = lean_ctor_get(x_186, 0);
+lean_inc(x_191);
+lean_dec(x_186);
+x_192 = lean_unsigned_to_nat(1u);
+x_193 = l_Array_getD___rarg(x_12, x_192, x_183);
+lean_dec(x_12);
+x_194 = 1;
+x_1 = x_194;
+x_2 = x_193;
+x_3 = x_191;
+x_5 = x_190;
+goto _start;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; size_t x_200; lean_object* x_201; lean_object* x_202; uint8_t x_203; 
+x_196 = lean_ctor_get(x_7, 1);
+lean_inc(x_196);
+lean_dec(x_7);
+x_197 = lean_ctor_get(x_8, 1);
+lean_inc(x_197);
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_198 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_198 = lean_box(0);
+}
+x_199 = lean_ctor_get(x_9, 1);
+lean_inc(x_199);
+x_200 = lean_ctor_get_usize(x_9, 2);
+if (lean_is_exclusive(x_9)) {
+ lean_ctor_release(x_9, 0);
+ lean_ctor_release(x_9, 1);
+ x_201 = x_9;
+} else {
+ lean_dec_ref(x_9);
+ x_201 = lean_box(0);
+}
+x_202 = l_Lean_nameToExprAux___main___closed__1;
+x_203 = lean_string_dec_eq(x_199, x_202);
+lean_dec(x_199);
+if (x_203 == 0)
+{
+lean_object* x_204; lean_object* x_205; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_dec(x_197);
+lean_dec(x_196);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_204 = lean_box(0);
+x_205 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_205, 0, x_204);
+lean_ctor_set(x_205, 1, x_5);
+return x_205;
+}
+else
+{
+lean_object* x_206; uint8_t x_207; 
+x_206 = l_Lean_Syntax_formatStx___main___closed__5;
+x_207 = lean_string_dec_eq(x_197, x_206);
+lean_dec(x_197);
+if (x_207 == 0)
+{
+lean_object* x_208; lean_object* x_209; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_dec(x_196);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_208 = lean_box(0);
+x_209 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_209, 0, x_208);
+lean_ctor_set(x_209, 1, x_5);
+return x_209;
+}
+else
+{
+lean_object* x_210; uint8_t x_211; 
+x_210 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_211 = lean_string_dec_eq(x_196, x_210);
+lean_dec(x_196);
+if (x_211 == 0)
+{
+lean_object* x_212; lean_object* x_213; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_212 = lean_box(0);
+x_213 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_213, 0, x_212);
+lean_ctor_set(x_213, 1, x_5);
+return x_213;
+}
+else
+{
+lean_object* x_214; uint8_t x_215; 
+x_214 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_215 = lean_string_dec_eq(x_15, x_214);
+if (x_215 == 0)
+{
+lean_object* x_216; uint8_t x_217; 
+x_216 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_217 = lean_string_dec_eq(x_15, x_216);
+if (x_217 == 0)
+{
+lean_object* x_218; uint8_t x_219; 
+x_218 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_219 = lean_string_dec_eq(x_15, x_218);
+lean_dec(x_15);
+if (x_219 == 0)
+{
+lean_object* x_220; lean_object* x_221; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_free_object(x_6);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_220 = lean_box(0);
+x_221 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_221, 0, x_220);
+lean_ctor_set(x_221, 1, x_5);
+return x_221;
+}
+else
+{
+lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; 
+if (lean_is_scalar(x_201)) {
+ x_222 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_222 = x_201;
+}
+lean_ctor_set(x_222, 0, x_10);
+lean_ctor_set(x_222, 1, x_202);
+lean_ctor_set_usize(x_222, 2, x_200);
+if (lean_is_scalar(x_198)) {
+ x_223 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_223 = x_198;
+}
+lean_ctor_set(x_223, 0, x_222);
+lean_ctor_set(x_223, 1, x_206);
+lean_ctor_set_usize(x_223, 2, x_200);
+x_224 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_224, 0, x_223);
+lean_ctor_set(x_224, 1, x_210);
+lean_ctor_set_usize(x_224, 2, x_200);
+lean_ctor_set(x_6, 1, x_218);
+lean_ctor_set(x_6, 0, x_224);
+lean_ctor_set_usize(x_6, 2, x_200);
+x_225 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_226 = lean_ctor_get(x_225, 0);
+lean_inc(x_226);
+x_227 = lean_ctor_get(x_225, 1);
+lean_inc(x_227);
+if (lean_is_exclusive(x_225)) {
+ lean_ctor_release(x_225, 0);
+ lean_ctor_release(x_225, 1);
+ x_228 = x_225;
+} else {
+ lean_dec_ref(x_225);
+ x_228 = lean_box(0);
+}
+x_229 = lean_array_push(x_3, x_226);
+x_230 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_230, 0, x_229);
+if (lean_is_scalar(x_228)) {
+ x_231 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_231 = x_228;
+}
+lean_ctor_set(x_231, 0, x_230);
+lean_ctor_set(x_231, 1, x_227);
+return x_231;
+}
+}
+else
+{
+lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_232 = lean_unsigned_to_nat(1u);
+x_233 = lean_box(0);
+x_234 = l_Array_getD___rarg(x_12, x_232, x_233);
+x_235 = l_Lean_Syntax_isNone(x_234);
+lean_dec(x_234);
+if (x_235 == 0)
+{
+lean_object* x_236; lean_object* x_237; 
+lean_dec(x_12);
+lean_dec(x_3);
+x_236 = lean_box(0);
+x_237 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_237, 0, x_236);
+lean_ctor_set(x_237, 1, x_5);
+return x_237;
+}
+else
+{
+lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; 
+x_238 = lean_unsigned_to_nat(0u);
+x_239 = l_Array_getD___rarg(x_12, x_238, x_233);
+lean_dec(x_12);
+x_240 = lean_array_push(x_3, x_239);
+x_241 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_241, 0, x_240);
+x_242 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_242, 0, x_241);
+lean_ctor_set(x_242, 1, x_5);
+return x_242;
+}
+}
+}
+else
+{
+lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; 
+lean_dec(x_201);
+lean_dec(x_198);
+lean_free_object(x_6);
+lean_dec(x_15);
+lean_free_object(x_2);
+x_243 = lean_unsigned_to_nat(0u);
+x_244 = lean_box(0);
+x_245 = l_Array_getD___rarg(x_12, x_243, x_244);
+x_246 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_245, x_3, x_4, x_5);
+x_247 = lean_ctor_get(x_246, 0);
+lean_inc(x_247);
+if (lean_obj_tag(x_247) == 0)
+{
+lean_object* x_248; lean_object* x_249; lean_object* x_250; 
+lean_dec(x_12);
+x_248 = lean_ctor_get(x_246, 1);
+lean_inc(x_248);
+if (lean_is_exclusive(x_246)) {
+ lean_ctor_release(x_246, 0);
+ lean_ctor_release(x_246, 1);
+ x_249 = x_246;
+} else {
+ lean_dec_ref(x_246);
+ x_249 = lean_box(0);
+}
+if (lean_is_scalar(x_249)) {
+ x_250 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_250 = x_249;
+}
+lean_ctor_set(x_250, 0, x_247);
+lean_ctor_set(x_250, 1, x_248);
+return x_250;
+}
+else
+{
+lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; uint8_t x_255; 
+x_251 = lean_ctor_get(x_246, 1);
+lean_inc(x_251);
+lean_dec(x_246);
+x_252 = lean_ctor_get(x_247, 0);
+lean_inc(x_252);
+lean_dec(x_247);
+x_253 = lean_unsigned_to_nat(1u);
+x_254 = l_Array_getD___rarg(x_12, x_253, x_244);
+lean_dec(x_12);
+x_255 = 1;
+x_1 = x_255;
+x_2 = x_254;
+x_3 = x_252;
+x_5 = x_251;
+goto _start;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; size_t x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_257 = lean_ctor_get(x_6, 1);
+lean_inc(x_257);
+lean_dec(x_6);
+x_258 = lean_ctor_get(x_7, 1);
+lean_inc(x_258);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ x_259 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_259 = lean_box(0);
+}
+x_260 = lean_ctor_get(x_8, 1);
+lean_inc(x_260);
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_261 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_261 = lean_box(0);
+}
+x_262 = lean_ctor_get(x_9, 1);
+lean_inc(x_262);
+x_263 = lean_ctor_get_usize(x_9, 2);
+if (lean_is_exclusive(x_9)) {
+ lean_ctor_release(x_9, 0);
+ lean_ctor_release(x_9, 1);
+ x_264 = x_9;
+} else {
+ lean_dec_ref(x_9);
+ x_264 = lean_box(0);
+}
+x_265 = l_Lean_nameToExprAux___main___closed__1;
+x_266 = lean_string_dec_eq(x_262, x_265);
+lean_dec(x_262);
+if (x_266 == 0)
+{
+lean_object* x_267; lean_object* x_268; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_260);
+lean_dec(x_259);
+lean_dec(x_258);
+lean_dec(x_257);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_267 = lean_box(0);
+x_268 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_268, 0, x_267);
+lean_ctor_set(x_268, 1, x_5);
+return x_268;
+}
+else
+{
+lean_object* x_269; uint8_t x_270; 
+x_269 = l_Lean_Syntax_formatStx___main___closed__5;
+x_270 = lean_string_dec_eq(x_260, x_269);
+lean_dec(x_260);
+if (x_270 == 0)
+{
+lean_object* x_271; lean_object* x_272; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_259);
+lean_dec(x_258);
+lean_dec(x_257);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_271 = lean_box(0);
+x_272 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_272, 0, x_271);
+lean_ctor_set(x_272, 1, x_5);
+return x_272;
+}
+else
+{
+lean_object* x_273; uint8_t x_274; 
+x_273 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_274 = lean_string_dec_eq(x_258, x_273);
+lean_dec(x_258);
+if (x_274 == 0)
+{
+lean_object* x_275; lean_object* x_276; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_259);
+lean_dec(x_257);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_275 = lean_box(0);
+x_276 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_276, 0, x_275);
+lean_ctor_set(x_276, 1, x_5);
+return x_276;
+}
+else
+{
+lean_object* x_277; uint8_t x_278; 
+x_277 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_278 = lean_string_dec_eq(x_257, x_277);
+if (x_278 == 0)
+{
+lean_object* x_279; uint8_t x_280; 
+x_279 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_280 = lean_string_dec_eq(x_257, x_279);
+if (x_280 == 0)
+{
+lean_object* x_281; uint8_t x_282; 
+x_281 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_282 = lean_string_dec_eq(x_257, x_281);
+lean_dec(x_257);
+if (x_282 == 0)
+{
+lean_object* x_283; lean_object* x_284; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_259);
+lean_free_object(x_2);
+lean_dec(x_12);
+lean_dec(x_3);
+x_283 = lean_box(0);
+x_284 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_284, 0, x_283);
+lean_ctor_set(x_284, 1, x_5);
+return x_284;
+}
+else
+{
+lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; 
+if (lean_is_scalar(x_264)) {
+ x_285 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_285 = x_264;
+}
+lean_ctor_set(x_285, 0, x_10);
+lean_ctor_set(x_285, 1, x_265);
+lean_ctor_set_usize(x_285, 2, x_263);
+if (lean_is_scalar(x_261)) {
+ x_286 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_286 = x_261;
+}
+lean_ctor_set(x_286, 0, x_285);
+lean_ctor_set(x_286, 1, x_269);
+lean_ctor_set_usize(x_286, 2, x_263);
+if (lean_is_scalar(x_259)) {
+ x_287 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_287 = x_259;
+}
+lean_ctor_set(x_287, 0, x_286);
+lean_ctor_set(x_287, 1, x_273);
+lean_ctor_set_usize(x_287, 2, x_263);
+x_288 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_288, 0, x_287);
+lean_ctor_set(x_288, 1, x_281);
+lean_ctor_set_usize(x_288, 2, x_263);
+lean_ctor_set(x_2, 0, x_288);
+x_289 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_290 = lean_ctor_get(x_289, 0);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_289, 1);
+lean_inc(x_291);
+if (lean_is_exclusive(x_289)) {
+ lean_ctor_release(x_289, 0);
+ lean_ctor_release(x_289, 1);
+ x_292 = x_289;
+} else {
+ lean_dec_ref(x_289);
+ x_292 = lean_box(0);
+}
+x_293 = lean_array_push(x_3, x_290);
+x_294 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_294, 0, x_293);
+if (lean_is_scalar(x_292)) {
+ x_295 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_295 = x_292;
+}
+lean_ctor_set(x_295, 0, x_294);
+lean_ctor_set(x_295, 1, x_291);
+return x_295;
+}
+}
+else
+{
+lean_object* x_296; lean_object* x_297; lean_object* x_298; uint8_t x_299; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_259);
+lean_dec(x_257);
+lean_free_object(x_2);
+x_296 = lean_unsigned_to_nat(1u);
+x_297 = lean_box(0);
+x_298 = l_Array_getD___rarg(x_12, x_296, x_297);
+x_299 = l_Lean_Syntax_isNone(x_298);
+lean_dec(x_298);
+if (x_299 == 0)
+{
+lean_object* x_300; lean_object* x_301; 
+lean_dec(x_12);
+lean_dec(x_3);
+x_300 = lean_box(0);
+x_301 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_301, 0, x_300);
+lean_ctor_set(x_301, 1, x_5);
+return x_301;
+}
+else
+{
+lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; 
+x_302 = lean_unsigned_to_nat(0u);
+x_303 = l_Array_getD___rarg(x_12, x_302, x_297);
+lean_dec(x_12);
+x_304 = lean_array_push(x_3, x_303);
+x_305 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_305, 0, x_304);
+x_306 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_306, 0, x_305);
+lean_ctor_set(x_306, 1, x_5);
+return x_306;
+}
+}
+}
+else
+{
+lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; 
+lean_dec(x_264);
+lean_dec(x_261);
+lean_dec(x_259);
+lean_dec(x_257);
+lean_free_object(x_2);
+x_307 = lean_unsigned_to_nat(0u);
+x_308 = lean_box(0);
+x_309 = l_Array_getD___rarg(x_12, x_307, x_308);
+x_310 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_309, x_3, x_4, x_5);
+x_311 = lean_ctor_get(x_310, 0);
+lean_inc(x_311);
+if (lean_obj_tag(x_311) == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; 
+lean_dec(x_12);
+x_312 = lean_ctor_get(x_310, 1);
+lean_inc(x_312);
+if (lean_is_exclusive(x_310)) {
+ lean_ctor_release(x_310, 0);
+ lean_ctor_release(x_310, 1);
+ x_313 = x_310;
+} else {
+ lean_dec_ref(x_310);
+ x_313 = lean_box(0);
+}
+if (lean_is_scalar(x_313)) {
+ x_314 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_314 = x_313;
+}
+lean_ctor_set(x_314, 0, x_311);
+lean_ctor_set(x_314, 1, x_312);
+return x_314;
+}
+else
+{
+lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
+x_315 = lean_ctor_get(x_310, 1);
+lean_inc(x_315);
+lean_dec(x_310);
+x_316 = lean_ctor_get(x_311, 0);
+lean_inc(x_316);
+lean_dec(x_311);
+x_317 = lean_unsigned_to_nat(1u);
+x_318 = l_Array_getD___rarg(x_12, x_317, x_308);
+lean_dec(x_12);
+x_319 = 1;
+x_1 = x_319;
+x_2 = x_318;
+x_3 = x_316;
+x_5 = x_315;
+goto _start;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; size_t x_329; lean_object* x_330; lean_object* x_331; uint8_t x_332; 
+x_321 = lean_ctor_get(x_2, 1);
+lean_inc(x_321);
+lean_dec(x_2);
+x_322 = lean_ctor_get(x_6, 1);
+lean_inc(x_322);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ x_323 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_323 = lean_box(0);
+}
+x_324 = lean_ctor_get(x_7, 1);
+lean_inc(x_324);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ x_325 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_325 = lean_box(0);
+}
+x_326 = lean_ctor_get(x_8, 1);
+lean_inc(x_326);
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_327 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_327 = lean_box(0);
+}
+x_328 = lean_ctor_get(x_9, 1);
+lean_inc(x_328);
+x_329 = lean_ctor_get_usize(x_9, 2);
+if (lean_is_exclusive(x_9)) {
+ lean_ctor_release(x_9, 0);
+ lean_ctor_release(x_9, 1);
+ x_330 = x_9;
+} else {
+ lean_dec_ref(x_9);
+ x_330 = lean_box(0);
+}
+x_331 = l_Lean_nameToExprAux___main___closed__1;
+x_332 = lean_string_dec_eq(x_328, x_331);
+lean_dec(x_328);
+if (x_332 == 0)
+{
+lean_object* x_333; lean_object* x_334; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_326);
+lean_dec(x_325);
+lean_dec(x_324);
+lean_dec(x_323);
+lean_dec(x_322);
+lean_dec(x_321);
+lean_dec(x_3);
+x_333 = lean_box(0);
+x_334 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_334, 0, x_333);
+lean_ctor_set(x_334, 1, x_5);
+return x_334;
+}
+else
+{
+lean_object* x_335; uint8_t x_336; 
+x_335 = l_Lean_Syntax_formatStx___main___closed__5;
+x_336 = lean_string_dec_eq(x_326, x_335);
+lean_dec(x_326);
+if (x_336 == 0)
+{
+lean_object* x_337; lean_object* x_338; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_325);
+lean_dec(x_324);
+lean_dec(x_323);
+lean_dec(x_322);
+lean_dec(x_321);
+lean_dec(x_3);
+x_337 = lean_box(0);
+x_338 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_338, 0, x_337);
+lean_ctor_set(x_338, 1, x_5);
+return x_338;
+}
+else
+{
+lean_object* x_339; uint8_t x_340; 
+x_339 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_340 = lean_string_dec_eq(x_324, x_339);
+lean_dec(x_324);
+if (x_340 == 0)
+{
+lean_object* x_341; lean_object* x_342; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_325);
+lean_dec(x_323);
+lean_dec(x_322);
+lean_dec(x_321);
+lean_dec(x_3);
+x_341 = lean_box(0);
+x_342 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_342, 0, x_341);
+lean_ctor_set(x_342, 1, x_5);
+return x_342;
+}
+else
+{
+lean_object* x_343; uint8_t x_344; 
+x_343 = l_Lean_Parser_Term_app___elambda__1___closed__1;
+x_344 = lean_string_dec_eq(x_322, x_343);
+if (x_344 == 0)
+{
+lean_object* x_345; uint8_t x_346; 
+x_345 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_346 = lean_string_dec_eq(x_322, x_345);
+if (x_346 == 0)
+{
+lean_object* x_347; uint8_t x_348; 
+x_347 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_348 = lean_string_dec_eq(x_322, x_347);
+lean_dec(x_322);
+if (x_348 == 0)
+{
+lean_object* x_349; lean_object* x_350; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_325);
+lean_dec(x_323);
+lean_dec(x_321);
+lean_dec(x_3);
+x_349 = lean_box(0);
+x_350 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_350, 0, x_349);
+lean_ctor_set(x_350, 1, x_5);
+return x_350;
+}
+else
+{
+lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; 
+if (lean_is_scalar(x_330)) {
+ x_351 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_351 = x_330;
+}
+lean_ctor_set(x_351, 0, x_10);
+lean_ctor_set(x_351, 1, x_331);
+lean_ctor_set_usize(x_351, 2, x_329);
+if (lean_is_scalar(x_327)) {
+ x_352 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_352 = x_327;
+}
+lean_ctor_set(x_352, 0, x_351);
+lean_ctor_set(x_352, 1, x_335);
+lean_ctor_set_usize(x_352, 2, x_329);
+if (lean_is_scalar(x_325)) {
+ x_353 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_353 = x_325;
+}
+lean_ctor_set(x_353, 0, x_352);
+lean_ctor_set(x_353, 1, x_339);
+lean_ctor_set_usize(x_353, 2, x_329);
+if (lean_is_scalar(x_323)) {
+ x_354 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_354 = x_323;
+}
+lean_ctor_set(x_354, 0, x_353);
+lean_ctor_set(x_354, 1, x_347);
+lean_ctor_set_usize(x_354, 2, x_329);
+x_355 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_355, 0, x_354);
+lean_ctor_set(x_355, 1, x_321);
+x_356 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_355, x_4, x_5);
+lean_dec(x_355);
+x_357 = lean_ctor_get(x_356, 0);
+lean_inc(x_357);
+x_358 = lean_ctor_get(x_356, 1);
+lean_inc(x_358);
+if (lean_is_exclusive(x_356)) {
+ lean_ctor_release(x_356, 0);
+ lean_ctor_release(x_356, 1);
+ x_359 = x_356;
+} else {
+ lean_dec_ref(x_356);
+ x_359 = lean_box(0);
+}
+x_360 = lean_array_push(x_3, x_357);
+x_361 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_361, 0, x_360);
+if (lean_is_scalar(x_359)) {
+ x_362 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_362 = x_359;
+}
+lean_ctor_set(x_362, 0, x_361);
+lean_ctor_set(x_362, 1, x_358);
+return x_362;
+}
+}
+else
+{
+lean_object* x_363; lean_object* x_364; lean_object* x_365; uint8_t x_366; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_325);
+lean_dec(x_323);
+lean_dec(x_322);
+x_363 = lean_unsigned_to_nat(1u);
+x_364 = lean_box(0);
+x_365 = l_Array_getD___rarg(x_321, x_363, x_364);
+x_366 = l_Lean_Syntax_isNone(x_365);
+lean_dec(x_365);
+if (x_366 == 0)
+{
+lean_object* x_367; lean_object* x_368; 
+lean_dec(x_321);
+lean_dec(x_3);
+x_367 = lean_box(0);
+x_368 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_368, 0, x_367);
+lean_ctor_set(x_368, 1, x_5);
+return x_368;
+}
+else
+{
+lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; 
+x_369 = lean_unsigned_to_nat(0u);
+x_370 = l_Array_getD___rarg(x_321, x_369, x_364);
+lean_dec(x_321);
+x_371 = lean_array_push(x_3, x_370);
+x_372 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_372, 0, x_371);
+x_373 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_373, 0, x_372);
+lean_ctor_set(x_373, 1, x_5);
+return x_373;
+}
+}
+}
+else
+{
+lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; 
+lean_dec(x_330);
+lean_dec(x_327);
+lean_dec(x_325);
+lean_dec(x_323);
+lean_dec(x_322);
+x_374 = lean_unsigned_to_nat(0u);
+x_375 = lean_box(0);
+x_376 = l_Array_getD___rarg(x_321, x_374, x_375);
+x_377 = l_Lean_Elab_Term_getFunBinderIdsAux_x3f___main(x_1, x_376, x_3, x_4, x_5);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; lean_object* x_380; lean_object* x_381; 
+lean_dec(x_321);
+x_379 = lean_ctor_get(x_377, 1);
+lean_inc(x_379);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ x_380 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_380 = lean_box(0);
+}
+if (lean_is_scalar(x_380)) {
+ x_381 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_381 = x_380;
+}
+lean_ctor_set(x_381, 0, x_378);
+lean_ctor_set(x_381, 1, x_379);
+return x_381;
+}
+else
+{
+lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; uint8_t x_386; 
+x_382 = lean_ctor_get(x_377, 1);
+lean_inc(x_382);
+lean_dec(x_377);
+x_383 = lean_ctor_get(x_378, 0);
+lean_inc(x_383);
+lean_dec(x_378);
+x_384 = lean_unsigned_to_nat(1u);
+x_385 = l_Array_getD___rarg(x_321, x_384, x_375);
+lean_dec(x_321);
+x_386 = 1;
+x_1 = x_386;
+x_2 = x_385;
+x_3 = x_383;
+x_5 = x_382;
+goto _start;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_388; lean_object* x_389; 
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
@@ -26962,231 +28456,508 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-x_60 = lean_box(0);
-x_61 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_61, 0, x_60);
-lean_ctor_set(x_61, 1, x_5);
-return x_61;
+x_388 = lean_box(0);
+x_389 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_389, 0, x_388);
+lean_ctor_set(x_389, 1, x_5);
+return x_389;
 }
 }
 else
 {
-lean_object* x_62; lean_object* x_63; 
+lean_object* x_390; lean_object* x_391; 
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-x_62 = lean_box(0);
-x_63 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_63, 0, x_62);
-lean_ctor_set(x_63, 1, x_5);
-return x_63;
+x_390 = lean_box(0);
+x_391 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_391, 0, x_390);
+lean_ctor_set(x_391, 1, x_5);
+return x_391;
 }
 }
 else
 {
-lean_object* x_64; lean_object* x_65; 
+lean_object* x_392; lean_object* x_393; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-x_64 = lean_box(0);
-x_65 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_65, 0, x_64);
-lean_ctor_set(x_65, 1, x_5);
-return x_65;
+x_392 = lean_box(0);
+x_393 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_393, 0, x_392);
+lean_ctor_set(x_393, 1, x_5);
+return x_393;
 }
 }
 else
 {
-lean_object* x_66; lean_object* x_67; 
+lean_object* x_394; lean_object* x_395; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-x_66 = lean_box(0);
-x_67 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_67, 0, x_66);
-lean_ctor_set(x_67, 1, x_5);
-return x_67;
+x_394 = lean_box(0);
+x_395 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_395, 0, x_394);
+lean_ctor_set(x_395, 1, x_5);
+return x_395;
 }
 }
 else
 {
-lean_object* x_68; lean_object* x_69; 
+lean_object* x_396; lean_object* x_397; 
 lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-x_68 = lean_box(0);
-x_69 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_69, 0, x_68);
-lean_ctor_set(x_69, 1, x_5);
-return x_69;
+x_396 = lean_box(0);
+x_397 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_397, 0, x_396);
+lean_ctor_set(x_397, 1, x_5);
+return x_397;
 }
 }
 else
 {
-lean_object* x_70; lean_object* x_71; 
+lean_object* x_398; lean_object* x_399; 
 lean_dec(x_3);
 lean_dec(x_2);
-x_70 = lean_box(0);
-x_71 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_5);
-return x_71;
+x_398 = lean_box(0);
+x_399 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_399, 0, x_398);
+lean_ctor_set(x_399, 1, x_5);
+return x_399;
 }
 }
 else
 {
 if (lean_obj_tag(x_2) == 1)
 {
-lean_object* x_72; 
-x_72 = lean_ctor_get(x_2, 0);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 1)
+lean_object* x_400; 
+x_400 = lean_ctor_get(x_2, 0);
+lean_inc(x_400);
+if (lean_obj_tag(x_400) == 1)
 {
-lean_object* x_73; 
-x_73 = lean_ctor_get(x_72, 0);
-lean_inc(x_73);
-if (lean_obj_tag(x_73) == 1)
+lean_object* x_401; 
+x_401 = lean_ctor_get(x_400, 0);
+lean_inc(x_401);
+if (lean_obj_tag(x_401) == 1)
 {
-lean_object* x_74; 
-x_74 = lean_ctor_get(x_73, 0);
-lean_inc(x_74);
-if (lean_obj_tag(x_74) == 1)
+lean_object* x_402; 
+x_402 = lean_ctor_get(x_401, 0);
+lean_inc(x_402);
+if (lean_obj_tag(x_402) == 1)
 {
-lean_object* x_75; 
-x_75 = lean_ctor_get(x_74, 0);
-lean_inc(x_75);
-if (lean_obj_tag(x_75) == 1)
+lean_object* x_403; 
+x_403 = lean_ctor_get(x_402, 0);
+lean_inc(x_403);
+if (lean_obj_tag(x_403) == 1)
 {
-lean_object* x_76; 
-x_76 = lean_ctor_get(x_75, 0);
-lean_inc(x_76);
-if (lean_obj_tag(x_76) == 0)
+lean_object* x_404; 
+x_404 = lean_ctor_get(x_403, 0);
+lean_inc(x_404);
+if (lean_obj_tag(x_404) == 0)
 {
-lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; uint8_t x_83; 
-x_77 = lean_ctor_get(x_2, 1);
-lean_inc(x_77);
+uint8_t x_405; 
+x_405 = !lean_is_exclusive(x_2);
+if (x_405 == 0)
+{
+lean_object* x_406; lean_object* x_407; uint8_t x_408; 
+x_406 = lean_ctor_get(x_2, 1);
+x_407 = lean_ctor_get(x_2, 0);
+lean_dec(x_407);
+x_408 = !lean_is_exclusive(x_400);
+if (x_408 == 0)
+{
+lean_object* x_409; lean_object* x_410; uint8_t x_411; 
+x_409 = lean_ctor_get(x_400, 1);
+x_410 = lean_ctor_get(x_400, 0);
+lean_dec(x_410);
+x_411 = !lean_is_exclusive(x_401);
+if (x_411 == 0)
+{
+lean_object* x_412; lean_object* x_413; uint8_t x_414; 
+x_412 = lean_ctor_get(x_401, 1);
+x_413 = lean_ctor_get(x_401, 0);
+lean_dec(x_413);
+x_414 = !lean_is_exclusive(x_402);
+if (x_414 == 0)
+{
+lean_object* x_415; lean_object* x_416; uint8_t x_417; 
+x_415 = lean_ctor_get(x_402, 1);
+x_416 = lean_ctor_get(x_402, 0);
+lean_dec(x_416);
+x_417 = !lean_is_exclusive(x_403);
+if (x_417 == 0)
+{
+lean_object* x_418; size_t x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; 
+x_418 = lean_ctor_get(x_403, 1);
+x_419 = lean_ctor_get_usize(x_403, 2);
+x_420 = lean_ctor_get(x_403, 0);
+lean_dec(x_420);
+x_421 = l_Lean_nameToExprAux___main___closed__1;
+x_422 = lean_string_dec_eq(x_418, x_421);
+lean_dec(x_418);
+if (x_422 == 0)
+{
+lean_object* x_423; lean_object* x_424; 
+lean_free_object(x_403);
+lean_free_object(x_402);
+lean_dec(x_415);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_423 = lean_box(0);
+x_424 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_424, 0, x_423);
+lean_ctor_set(x_424, 1, x_5);
+return x_424;
+}
+else
+{
+lean_object* x_425; uint8_t x_426; 
+x_425 = l_Lean_Syntax_formatStx___main___closed__5;
+x_426 = lean_string_dec_eq(x_415, x_425);
+lean_dec(x_415);
+if (x_426 == 0)
+{
+lean_object* x_427; lean_object* x_428; 
+lean_free_object(x_403);
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_427 = lean_box(0);
+x_428 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_428, 0, x_427);
+lean_ctor_set(x_428, 1, x_5);
+return x_428;
+}
+else
+{
+lean_object* x_429; uint8_t x_430; 
+x_429 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_430 = lean_string_dec_eq(x_412, x_429);
+lean_dec(x_412);
+if (x_430 == 0)
+{
+lean_object* x_431; lean_object* x_432; 
+lean_free_object(x_403);
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_431 = lean_box(0);
+x_432 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_432, 0, x_431);
+lean_ctor_set(x_432, 1, x_5);
+return x_432;
+}
+else
+{
+lean_object* x_433; uint8_t x_434; 
+x_433 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_434 = lean_string_dec_eq(x_409, x_433);
+if (x_434 == 0)
+{
+lean_object* x_435; uint8_t x_436; 
+x_435 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_436 = lean_string_dec_eq(x_409, x_435);
+lean_dec(x_409);
+if (x_436 == 0)
+{
+lean_object* x_437; lean_object* x_438; 
+lean_free_object(x_403);
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_437 = lean_box(0);
+x_438 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_438, 0, x_437);
+lean_ctor_set(x_438, 1, x_5);
+return x_438;
+}
+else
+{
+lean_object* x_439; uint8_t x_440; 
+lean_ctor_set(x_403, 1, x_421);
+lean_ctor_set(x_402, 1, x_425);
+lean_ctor_set_usize(x_402, 2, x_419);
+lean_ctor_set(x_401, 1, x_429);
+lean_ctor_set_usize(x_401, 2, x_419);
+lean_ctor_set(x_400, 1, x_435);
+lean_ctor_set_usize(x_400, 2, x_419);
+x_439 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
 lean_dec(x_2);
-x_78 = lean_ctor_get(x_72, 1);
-lean_inc(x_78);
-lean_dec(x_72);
-x_79 = lean_ctor_get(x_73, 1);
-lean_inc(x_79);
-lean_dec(x_73);
-x_80 = lean_ctor_get(x_74, 1);
-lean_inc(x_80);
-lean_dec(x_74);
-x_81 = lean_ctor_get(x_75, 1);
-lean_inc(x_81);
-lean_dec(x_75);
-x_82 = l_Lean_nameToExprAux___main___closed__1;
-x_83 = lean_string_dec_eq(x_81, x_82);
-lean_dec(x_81);
-if (x_83 == 0)
+x_440 = !lean_is_exclusive(x_439);
+if (x_440 == 0)
 {
-lean_object* x_84; lean_object* x_85; 
-lean_dec(x_80);
-lean_dec(x_79);
-lean_dec(x_78);
-lean_dec(x_77);
+lean_object* x_441; lean_object* x_442; lean_object* x_443; 
+x_441 = lean_ctor_get(x_439, 0);
+x_442 = lean_array_push(x_3, x_441);
+x_443 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_443, 0, x_442);
+lean_ctor_set(x_439, 0, x_443);
+return x_439;
+}
+else
+{
+lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; 
+x_444 = lean_ctor_get(x_439, 0);
+x_445 = lean_ctor_get(x_439, 1);
+lean_inc(x_445);
+lean_inc(x_444);
+lean_dec(x_439);
+x_446 = lean_array_push(x_3, x_444);
+x_447 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_447, 0, x_446);
+x_448 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_448, 0, x_447);
+lean_ctor_set(x_448, 1, x_445);
+return x_448;
+}
+}
+}
+else
+{
+lean_object* x_449; lean_object* x_450; lean_object* x_451; uint8_t x_452; 
+lean_free_object(x_403);
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+x_449 = lean_unsigned_to_nat(1u);
+x_450 = lean_box(0);
+x_451 = l_Array_getD___rarg(x_406, x_449, x_450);
+x_452 = l_Lean_Syntax_isNone(x_451);
+lean_dec(x_451);
+if (x_452 == 0)
+{
+lean_object* x_453; lean_object* x_454; 
+lean_dec(x_406);
 lean_dec(x_3);
-x_84 = lean_box(0);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_5);
-return x_85;
+x_453 = lean_box(0);
+x_454 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_454, 0, x_453);
+lean_ctor_set(x_454, 1, x_5);
+return x_454;
 }
 else
 {
-lean_object* x_86; uint8_t x_87; 
-x_86 = l_Lean_Syntax_formatStx___main___closed__5;
-x_87 = lean_string_dec_eq(x_80, x_86);
-lean_dec(x_80);
-if (x_87 == 0)
+lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; 
+x_455 = lean_unsigned_to_nat(0u);
+x_456 = l_Array_getD___rarg(x_406, x_455, x_450);
+lean_dec(x_406);
+x_457 = lean_array_push(x_3, x_456);
+x_458 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_458, 0, x_457);
+x_459 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_459, 0, x_458);
+lean_ctor_set(x_459, 1, x_5);
+return x_459;
+}
+}
+}
+}
+}
+}
+else
 {
-lean_object* x_88; lean_object* x_89; 
-lean_dec(x_79);
-lean_dec(x_78);
-lean_dec(x_77);
+lean_object* x_460; size_t x_461; lean_object* x_462; uint8_t x_463; 
+x_460 = lean_ctor_get(x_403, 1);
+x_461 = lean_ctor_get_usize(x_403, 2);
+lean_inc(x_460);
+lean_dec(x_403);
+x_462 = l_Lean_nameToExprAux___main___closed__1;
+x_463 = lean_string_dec_eq(x_460, x_462);
+lean_dec(x_460);
+if (x_463 == 0)
+{
+lean_object* x_464; lean_object* x_465; 
+lean_free_object(x_402);
+lean_dec(x_415);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
 lean_dec(x_3);
-x_88 = lean_box(0);
-x_89 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_89, 0, x_88);
-lean_ctor_set(x_89, 1, x_5);
-return x_89;
+x_464 = lean_box(0);
+x_465 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_465, 0, x_464);
+lean_ctor_set(x_465, 1, x_5);
+return x_465;
 }
 else
 {
-lean_object* x_90; uint8_t x_91; 
-x_90 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
-x_91 = lean_string_dec_eq(x_79, x_90);
-lean_dec(x_79);
-if (x_91 == 0)
+lean_object* x_466; uint8_t x_467; 
+x_466 = l_Lean_Syntax_formatStx___main___closed__5;
+x_467 = lean_string_dec_eq(x_415, x_466);
+lean_dec(x_415);
+if (x_467 == 0)
 {
-lean_object* x_92; lean_object* x_93; 
-lean_dec(x_78);
-lean_dec(x_77);
+lean_object* x_468; lean_object* x_469; 
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
 lean_dec(x_3);
-x_92 = lean_box(0);
-x_93 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_93, 0, x_92);
-lean_ctor_set(x_93, 1, x_5);
-return x_93;
+x_468 = lean_box(0);
+x_469 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_469, 0, x_468);
+lean_ctor_set(x_469, 1, x_5);
+return x_469;
 }
 else
 {
-lean_object* x_94; uint8_t x_95; 
-x_94 = l_Lean_Parser_Term_id___elambda__1___closed__1;
-x_95 = lean_string_dec_eq(x_78, x_94);
-lean_dec(x_78);
-if (x_95 == 0)
+lean_object* x_470; uint8_t x_471; 
+x_470 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_471 = lean_string_dec_eq(x_412, x_470);
+lean_dec(x_412);
+if (x_471 == 0)
 {
-lean_object* x_96; lean_object* x_97; 
-lean_dec(x_77);
+lean_object* x_472; lean_object* x_473; 
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
 lean_dec(x_3);
-x_96 = lean_box(0);
-x_97 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_97, 0, x_96);
-lean_ctor_set(x_97, 1, x_5);
-return x_97;
+x_472 = lean_box(0);
+x_473 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_473, 0, x_472);
+lean_ctor_set(x_473, 1, x_5);
+return x_473;
 }
 else
 {
-lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; 
-x_98 = lean_unsigned_to_nat(1u);
-x_99 = lean_box(0);
-x_100 = l_Array_getD___rarg(x_77, x_98, x_99);
-x_101 = l_Lean_Syntax_isNone(x_100);
-lean_dec(x_100);
-if (x_101 == 0)
+lean_object* x_474; uint8_t x_475; 
+x_474 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_475 = lean_string_dec_eq(x_409, x_474);
+if (x_475 == 0)
 {
-lean_object* x_102; lean_object* x_103; 
-lean_dec(x_77);
+lean_object* x_476; uint8_t x_477; 
+x_476 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_477 = lean_string_dec_eq(x_409, x_476);
+lean_dec(x_409);
+if (x_477 == 0)
+{
+lean_object* x_478; lean_object* x_479; 
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_free_object(x_2);
+lean_dec(x_406);
 lean_dec(x_3);
-x_102 = lean_box(0);
-x_103 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_103, 0, x_102);
-lean_ctor_set(x_103, 1, x_5);
-return x_103;
+x_478 = lean_box(0);
+x_479 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_479, 0, x_478);
+lean_ctor_set(x_479, 1, x_5);
+return x_479;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
-x_104 = lean_unsigned_to_nat(0u);
-x_105 = l_Array_getD___rarg(x_77, x_104, x_99);
-lean_dec(x_77);
-x_106 = lean_array_push(x_3, x_105);
-x_107 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_107, 0, x_106);
-x_108 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_108, 0, x_107);
-lean_ctor_set(x_108, 1, x_5);
-return x_108;
+lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; 
+x_480 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_480, 0, x_404);
+lean_ctor_set(x_480, 1, x_462);
+lean_ctor_set_usize(x_480, 2, x_461);
+lean_ctor_set(x_402, 1, x_466);
+lean_ctor_set(x_402, 0, x_480);
+lean_ctor_set_usize(x_402, 2, x_461);
+lean_ctor_set(x_401, 1, x_470);
+lean_ctor_set_usize(x_401, 2, x_461);
+lean_ctor_set(x_400, 1, x_476);
+lean_ctor_set_usize(x_400, 2, x_461);
+x_481 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_482 = lean_ctor_get(x_481, 0);
+lean_inc(x_482);
+x_483 = lean_ctor_get(x_481, 1);
+lean_inc(x_483);
+if (lean_is_exclusive(x_481)) {
+ lean_ctor_release(x_481, 0);
+ lean_ctor_release(x_481, 1);
+ x_484 = x_481;
+} else {
+ lean_dec_ref(x_481);
+ x_484 = lean_box(0);
+}
+x_485 = lean_array_push(x_3, x_482);
+x_486 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_486, 0, x_485);
+if (lean_is_scalar(x_484)) {
+ x_487 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_487 = x_484;
+}
+lean_ctor_set(x_487, 0, x_486);
+lean_ctor_set(x_487, 1, x_483);
+return x_487;
+}
+}
+else
+{
+lean_object* x_488; lean_object* x_489; lean_object* x_490; uint8_t x_491; 
+lean_free_object(x_402);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+x_488 = lean_unsigned_to_nat(1u);
+x_489 = lean_box(0);
+x_490 = l_Array_getD___rarg(x_406, x_488, x_489);
+x_491 = l_Lean_Syntax_isNone(x_490);
+lean_dec(x_490);
+if (x_491 == 0)
+{
+lean_object* x_492; lean_object* x_493; 
+lean_dec(x_406);
+lean_dec(x_3);
+x_492 = lean_box(0);
+x_493 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_493, 0, x_492);
+lean_ctor_set(x_493, 1, x_5);
+return x_493;
+}
+else
+{
+lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; 
+x_494 = lean_unsigned_to_nat(0u);
+x_495 = l_Array_getD___rarg(x_406, x_494, x_489);
+lean_dec(x_406);
+x_496 = lean_array_push(x_3, x_495);
+x_497 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_497, 0, x_496);
+x_498 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_498, 0, x_497);
+lean_ctor_set(x_498, 1, x_5);
+return x_498;
+}
 }
 }
 }
@@ -27195,89 +28966,985 @@ return x_108;
 }
 else
 {
-lean_object* x_109; lean_object* x_110; 
-lean_dec(x_76);
-lean_dec(x_75);
-lean_dec(x_74);
-lean_dec(x_73);
-lean_dec(x_72);
+lean_object* x_499; lean_object* x_500; size_t x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; 
+x_499 = lean_ctor_get(x_402, 1);
+lean_inc(x_499);
+lean_dec(x_402);
+x_500 = lean_ctor_get(x_403, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get_usize(x_403, 2);
+if (lean_is_exclusive(x_403)) {
+ lean_ctor_release(x_403, 0);
+ lean_ctor_release(x_403, 1);
+ x_502 = x_403;
+} else {
+ lean_dec_ref(x_403);
+ x_502 = lean_box(0);
+}
+x_503 = l_Lean_nameToExprAux___main___closed__1;
+x_504 = lean_string_dec_eq(x_500, x_503);
+lean_dec(x_500);
+if (x_504 == 0)
+{
+lean_object* x_505; lean_object* x_506; 
+lean_dec(x_502);
+lean_dec(x_499);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_505 = lean_box(0);
+x_506 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_506, 0, x_505);
+lean_ctor_set(x_506, 1, x_5);
+return x_506;
+}
+else
+{
+lean_object* x_507; uint8_t x_508; 
+x_507 = l_Lean_Syntax_formatStx___main___closed__5;
+x_508 = lean_string_dec_eq(x_499, x_507);
+lean_dec(x_499);
+if (x_508 == 0)
+{
+lean_object* x_509; lean_object* x_510; 
+lean_dec(x_502);
+lean_free_object(x_401);
+lean_dec(x_412);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_509 = lean_box(0);
+x_510 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_510, 0, x_509);
+lean_ctor_set(x_510, 1, x_5);
+return x_510;
+}
+else
+{
+lean_object* x_511; uint8_t x_512; 
+x_511 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_512 = lean_string_dec_eq(x_412, x_511);
+lean_dec(x_412);
+if (x_512 == 0)
+{
+lean_object* x_513; lean_object* x_514; 
+lean_dec(x_502);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_513 = lean_box(0);
+x_514 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_514, 0, x_513);
+lean_ctor_set(x_514, 1, x_5);
+return x_514;
+}
+else
+{
+lean_object* x_515; uint8_t x_516; 
+x_515 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_516 = lean_string_dec_eq(x_409, x_515);
+if (x_516 == 0)
+{
+lean_object* x_517; uint8_t x_518; 
+x_517 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_518 = lean_string_dec_eq(x_409, x_517);
+lean_dec(x_409);
+if (x_518 == 0)
+{
+lean_object* x_519; lean_object* x_520; 
+lean_dec(x_502);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_519 = lean_box(0);
+x_520 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_520, 0, x_519);
+lean_ctor_set(x_520, 1, x_5);
+return x_520;
+}
+else
+{
+lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; 
+if (lean_is_scalar(x_502)) {
+ x_521 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_521 = x_502;
+}
+lean_ctor_set(x_521, 0, x_404);
+lean_ctor_set(x_521, 1, x_503);
+lean_ctor_set_usize(x_521, 2, x_501);
+x_522 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_522, 0, x_521);
+lean_ctor_set(x_522, 1, x_507);
+lean_ctor_set_usize(x_522, 2, x_501);
+lean_ctor_set(x_401, 1, x_511);
+lean_ctor_set(x_401, 0, x_522);
+lean_ctor_set_usize(x_401, 2, x_501);
+lean_ctor_set(x_400, 1, x_517);
+lean_ctor_set_usize(x_400, 2, x_501);
+x_523 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_524 = lean_ctor_get(x_523, 0);
+lean_inc(x_524);
+x_525 = lean_ctor_get(x_523, 1);
+lean_inc(x_525);
+if (lean_is_exclusive(x_523)) {
+ lean_ctor_release(x_523, 0);
+ lean_ctor_release(x_523, 1);
+ x_526 = x_523;
+} else {
+ lean_dec_ref(x_523);
+ x_526 = lean_box(0);
+}
+x_527 = lean_array_push(x_3, x_524);
+x_528 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_528, 0, x_527);
+if (lean_is_scalar(x_526)) {
+ x_529 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_529 = x_526;
+}
+lean_ctor_set(x_529, 0, x_528);
+lean_ctor_set(x_529, 1, x_525);
+return x_529;
+}
+}
+else
+{
+lean_object* x_530; lean_object* x_531; lean_object* x_532; uint8_t x_533; 
+lean_dec(x_502);
+lean_free_object(x_401);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+x_530 = lean_unsigned_to_nat(1u);
+x_531 = lean_box(0);
+x_532 = l_Array_getD___rarg(x_406, x_530, x_531);
+x_533 = l_Lean_Syntax_isNone(x_532);
+lean_dec(x_532);
+if (x_533 == 0)
+{
+lean_object* x_534; lean_object* x_535; 
+lean_dec(x_406);
+lean_dec(x_3);
+x_534 = lean_box(0);
+x_535 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_535, 0, x_534);
+lean_ctor_set(x_535, 1, x_5);
+return x_535;
+}
+else
+{
+lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; 
+x_536 = lean_unsigned_to_nat(0u);
+x_537 = l_Array_getD___rarg(x_406, x_536, x_531);
+lean_dec(x_406);
+x_538 = lean_array_push(x_3, x_537);
+x_539 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_539, 0, x_538);
+x_540 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_540, 0, x_539);
+lean_ctor_set(x_540, 1, x_5);
+return x_540;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; size_t x_545; lean_object* x_546; lean_object* x_547; uint8_t x_548; 
+x_541 = lean_ctor_get(x_401, 1);
+lean_inc(x_541);
+lean_dec(x_401);
+x_542 = lean_ctor_get(x_402, 1);
+lean_inc(x_542);
+if (lean_is_exclusive(x_402)) {
+ lean_ctor_release(x_402, 0);
+ lean_ctor_release(x_402, 1);
+ x_543 = x_402;
+} else {
+ lean_dec_ref(x_402);
+ x_543 = lean_box(0);
+}
+x_544 = lean_ctor_get(x_403, 1);
+lean_inc(x_544);
+x_545 = lean_ctor_get_usize(x_403, 2);
+if (lean_is_exclusive(x_403)) {
+ lean_ctor_release(x_403, 0);
+ lean_ctor_release(x_403, 1);
+ x_546 = x_403;
+} else {
+ lean_dec_ref(x_403);
+ x_546 = lean_box(0);
+}
+x_547 = l_Lean_nameToExprAux___main___closed__1;
+x_548 = lean_string_dec_eq(x_544, x_547);
+lean_dec(x_544);
+if (x_548 == 0)
+{
+lean_object* x_549; lean_object* x_550; 
+lean_dec(x_546);
+lean_dec(x_543);
+lean_dec(x_542);
+lean_dec(x_541);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_549 = lean_box(0);
+x_550 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_550, 0, x_549);
+lean_ctor_set(x_550, 1, x_5);
+return x_550;
+}
+else
+{
+lean_object* x_551; uint8_t x_552; 
+x_551 = l_Lean_Syntax_formatStx___main___closed__5;
+x_552 = lean_string_dec_eq(x_542, x_551);
+lean_dec(x_542);
+if (x_552 == 0)
+{
+lean_object* x_553; lean_object* x_554; 
+lean_dec(x_546);
+lean_dec(x_543);
+lean_dec(x_541);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_553 = lean_box(0);
+x_554 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_554, 0, x_553);
+lean_ctor_set(x_554, 1, x_5);
+return x_554;
+}
+else
+{
+lean_object* x_555; uint8_t x_556; 
+x_555 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_556 = lean_string_dec_eq(x_541, x_555);
+lean_dec(x_541);
+if (x_556 == 0)
+{
+lean_object* x_557; lean_object* x_558; 
+lean_dec(x_546);
+lean_dec(x_543);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_557 = lean_box(0);
+x_558 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_558, 0, x_557);
+lean_ctor_set(x_558, 1, x_5);
+return x_558;
+}
+else
+{
+lean_object* x_559; uint8_t x_560; 
+x_559 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_560 = lean_string_dec_eq(x_409, x_559);
+if (x_560 == 0)
+{
+lean_object* x_561; uint8_t x_562; 
+x_561 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_562 = lean_string_dec_eq(x_409, x_561);
+lean_dec(x_409);
+if (x_562 == 0)
+{
+lean_object* x_563; lean_object* x_564; 
+lean_dec(x_546);
+lean_dec(x_543);
+lean_free_object(x_400);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_563 = lean_box(0);
+x_564 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_564, 0, x_563);
+lean_ctor_set(x_564, 1, x_5);
+return x_564;
+}
+else
+{
+lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; 
+if (lean_is_scalar(x_546)) {
+ x_565 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_565 = x_546;
+}
+lean_ctor_set(x_565, 0, x_404);
+lean_ctor_set(x_565, 1, x_547);
+lean_ctor_set_usize(x_565, 2, x_545);
+if (lean_is_scalar(x_543)) {
+ x_566 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_566 = x_543;
+}
+lean_ctor_set(x_566, 0, x_565);
+lean_ctor_set(x_566, 1, x_551);
+lean_ctor_set_usize(x_566, 2, x_545);
+x_567 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_567, 0, x_566);
+lean_ctor_set(x_567, 1, x_555);
+lean_ctor_set_usize(x_567, 2, x_545);
+lean_ctor_set(x_400, 1, x_561);
+lean_ctor_set(x_400, 0, x_567);
+lean_ctor_set_usize(x_400, 2, x_545);
+x_568 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_569 = lean_ctor_get(x_568, 0);
+lean_inc(x_569);
+x_570 = lean_ctor_get(x_568, 1);
+lean_inc(x_570);
+if (lean_is_exclusive(x_568)) {
+ lean_ctor_release(x_568, 0);
+ lean_ctor_release(x_568, 1);
+ x_571 = x_568;
+} else {
+ lean_dec_ref(x_568);
+ x_571 = lean_box(0);
+}
+x_572 = lean_array_push(x_3, x_569);
+x_573 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_573, 0, x_572);
+if (lean_is_scalar(x_571)) {
+ x_574 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_574 = x_571;
+}
+lean_ctor_set(x_574, 0, x_573);
+lean_ctor_set(x_574, 1, x_570);
+return x_574;
+}
+}
+else
+{
+lean_object* x_575; lean_object* x_576; lean_object* x_577; uint8_t x_578; 
+lean_dec(x_546);
+lean_dec(x_543);
+lean_free_object(x_400);
+lean_dec(x_409);
+lean_free_object(x_2);
+x_575 = lean_unsigned_to_nat(1u);
+x_576 = lean_box(0);
+x_577 = l_Array_getD___rarg(x_406, x_575, x_576);
+x_578 = l_Lean_Syntax_isNone(x_577);
+lean_dec(x_577);
+if (x_578 == 0)
+{
+lean_object* x_579; lean_object* x_580; 
+lean_dec(x_406);
+lean_dec(x_3);
+x_579 = lean_box(0);
+x_580 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_580, 0, x_579);
+lean_ctor_set(x_580, 1, x_5);
+return x_580;
+}
+else
+{
+lean_object* x_581; lean_object* x_582; lean_object* x_583; lean_object* x_584; lean_object* x_585; 
+x_581 = lean_unsigned_to_nat(0u);
+x_582 = l_Array_getD___rarg(x_406, x_581, x_576);
+lean_dec(x_406);
+x_583 = lean_array_push(x_3, x_582);
+x_584 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_584, 0, x_583);
+x_585 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_585, 0, x_584);
+lean_ctor_set(x_585, 1, x_5);
+return x_585;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; lean_object* x_591; size_t x_592; lean_object* x_593; lean_object* x_594; uint8_t x_595; 
+x_586 = lean_ctor_get(x_400, 1);
+lean_inc(x_586);
+lean_dec(x_400);
+x_587 = lean_ctor_get(x_401, 1);
+lean_inc(x_587);
+if (lean_is_exclusive(x_401)) {
+ lean_ctor_release(x_401, 0);
+ lean_ctor_release(x_401, 1);
+ x_588 = x_401;
+} else {
+ lean_dec_ref(x_401);
+ x_588 = lean_box(0);
+}
+x_589 = lean_ctor_get(x_402, 1);
+lean_inc(x_589);
+if (lean_is_exclusive(x_402)) {
+ lean_ctor_release(x_402, 0);
+ lean_ctor_release(x_402, 1);
+ x_590 = x_402;
+} else {
+ lean_dec_ref(x_402);
+ x_590 = lean_box(0);
+}
+x_591 = lean_ctor_get(x_403, 1);
+lean_inc(x_591);
+x_592 = lean_ctor_get_usize(x_403, 2);
+if (lean_is_exclusive(x_403)) {
+ lean_ctor_release(x_403, 0);
+ lean_ctor_release(x_403, 1);
+ x_593 = x_403;
+} else {
+ lean_dec_ref(x_403);
+ x_593 = lean_box(0);
+}
+x_594 = l_Lean_nameToExprAux___main___closed__1;
+x_595 = lean_string_dec_eq(x_591, x_594);
+lean_dec(x_591);
+if (x_595 == 0)
+{
+lean_object* x_596; lean_object* x_597; 
+lean_dec(x_593);
+lean_dec(x_590);
+lean_dec(x_589);
+lean_dec(x_588);
+lean_dec(x_587);
+lean_dec(x_586);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_596 = lean_box(0);
+x_597 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_597, 0, x_596);
+lean_ctor_set(x_597, 1, x_5);
+return x_597;
+}
+else
+{
+lean_object* x_598; uint8_t x_599; 
+x_598 = l_Lean_Syntax_formatStx___main___closed__5;
+x_599 = lean_string_dec_eq(x_589, x_598);
+lean_dec(x_589);
+if (x_599 == 0)
+{
+lean_object* x_600; lean_object* x_601; 
+lean_dec(x_593);
+lean_dec(x_590);
+lean_dec(x_588);
+lean_dec(x_587);
+lean_dec(x_586);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_600 = lean_box(0);
+x_601 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_601, 0, x_600);
+lean_ctor_set(x_601, 1, x_5);
+return x_601;
+}
+else
+{
+lean_object* x_602; uint8_t x_603; 
+x_602 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_603 = lean_string_dec_eq(x_587, x_602);
+lean_dec(x_587);
+if (x_603 == 0)
+{
+lean_object* x_604; lean_object* x_605; 
+lean_dec(x_593);
+lean_dec(x_590);
+lean_dec(x_588);
+lean_dec(x_586);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_604 = lean_box(0);
+x_605 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_605, 0, x_604);
+lean_ctor_set(x_605, 1, x_5);
+return x_605;
+}
+else
+{
+lean_object* x_606; uint8_t x_607; 
+x_606 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_607 = lean_string_dec_eq(x_586, x_606);
+if (x_607 == 0)
+{
+lean_object* x_608; uint8_t x_609; 
+x_608 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_609 = lean_string_dec_eq(x_586, x_608);
+lean_dec(x_586);
+if (x_609 == 0)
+{
+lean_object* x_610; lean_object* x_611; 
+lean_dec(x_593);
+lean_dec(x_590);
+lean_dec(x_588);
+lean_free_object(x_2);
+lean_dec(x_406);
+lean_dec(x_3);
+x_610 = lean_box(0);
+x_611 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_611, 0, x_610);
+lean_ctor_set(x_611, 1, x_5);
+return x_611;
+}
+else
+{
+lean_object* x_612; lean_object* x_613; lean_object* x_614; lean_object* x_615; lean_object* x_616; lean_object* x_617; lean_object* x_618; lean_object* x_619; lean_object* x_620; lean_object* x_621; lean_object* x_622; 
+if (lean_is_scalar(x_593)) {
+ x_612 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_612 = x_593;
+}
+lean_ctor_set(x_612, 0, x_404);
+lean_ctor_set(x_612, 1, x_594);
+lean_ctor_set_usize(x_612, 2, x_592);
+if (lean_is_scalar(x_590)) {
+ x_613 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_613 = x_590;
+}
+lean_ctor_set(x_613, 0, x_612);
+lean_ctor_set(x_613, 1, x_598);
+lean_ctor_set_usize(x_613, 2, x_592);
+if (lean_is_scalar(x_588)) {
+ x_614 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_614 = x_588;
+}
+lean_ctor_set(x_614, 0, x_613);
+lean_ctor_set(x_614, 1, x_602);
+lean_ctor_set_usize(x_614, 2, x_592);
+x_615 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_615, 0, x_614);
+lean_ctor_set(x_615, 1, x_608);
+lean_ctor_set_usize(x_615, 2, x_592);
+lean_ctor_set(x_2, 0, x_615);
+x_616 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_2, x_4, x_5);
+lean_dec(x_2);
+x_617 = lean_ctor_get(x_616, 0);
+lean_inc(x_617);
+x_618 = lean_ctor_get(x_616, 1);
+lean_inc(x_618);
+if (lean_is_exclusive(x_616)) {
+ lean_ctor_release(x_616, 0);
+ lean_ctor_release(x_616, 1);
+ x_619 = x_616;
+} else {
+ lean_dec_ref(x_616);
+ x_619 = lean_box(0);
+}
+x_620 = lean_array_push(x_3, x_617);
+x_621 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_621, 0, x_620);
+if (lean_is_scalar(x_619)) {
+ x_622 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_622 = x_619;
+}
+lean_ctor_set(x_622, 0, x_621);
+lean_ctor_set(x_622, 1, x_618);
+return x_622;
+}
+}
+else
+{
+lean_object* x_623; lean_object* x_624; lean_object* x_625; uint8_t x_626; 
+lean_dec(x_593);
+lean_dec(x_590);
+lean_dec(x_588);
+lean_dec(x_586);
+lean_free_object(x_2);
+x_623 = lean_unsigned_to_nat(1u);
+x_624 = lean_box(0);
+x_625 = l_Array_getD___rarg(x_406, x_623, x_624);
+x_626 = l_Lean_Syntax_isNone(x_625);
+lean_dec(x_625);
+if (x_626 == 0)
+{
+lean_object* x_627; lean_object* x_628; 
+lean_dec(x_406);
+lean_dec(x_3);
+x_627 = lean_box(0);
+x_628 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_628, 0, x_627);
+lean_ctor_set(x_628, 1, x_5);
+return x_628;
+}
+else
+{
+lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; 
+x_629 = lean_unsigned_to_nat(0u);
+x_630 = l_Array_getD___rarg(x_406, x_629, x_624);
+lean_dec(x_406);
+x_631 = lean_array_push(x_3, x_630);
+x_632 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_632, 0, x_631);
+x_633 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_633, 0, x_632);
+lean_ctor_set(x_633, 1, x_5);
+return x_633;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_634; lean_object* x_635; lean_object* x_636; lean_object* x_637; lean_object* x_638; lean_object* x_639; lean_object* x_640; lean_object* x_641; size_t x_642; lean_object* x_643; lean_object* x_644; uint8_t x_645; 
+x_634 = lean_ctor_get(x_2, 1);
+lean_inc(x_634);
+lean_dec(x_2);
+x_635 = lean_ctor_get(x_400, 1);
+lean_inc(x_635);
+if (lean_is_exclusive(x_400)) {
+ lean_ctor_release(x_400, 0);
+ lean_ctor_release(x_400, 1);
+ x_636 = x_400;
+} else {
+ lean_dec_ref(x_400);
+ x_636 = lean_box(0);
+}
+x_637 = lean_ctor_get(x_401, 1);
+lean_inc(x_637);
+if (lean_is_exclusive(x_401)) {
+ lean_ctor_release(x_401, 0);
+ lean_ctor_release(x_401, 1);
+ x_638 = x_401;
+} else {
+ lean_dec_ref(x_401);
+ x_638 = lean_box(0);
+}
+x_639 = lean_ctor_get(x_402, 1);
+lean_inc(x_639);
+if (lean_is_exclusive(x_402)) {
+ lean_ctor_release(x_402, 0);
+ lean_ctor_release(x_402, 1);
+ x_640 = x_402;
+} else {
+ lean_dec_ref(x_402);
+ x_640 = lean_box(0);
+}
+x_641 = lean_ctor_get(x_403, 1);
+lean_inc(x_641);
+x_642 = lean_ctor_get_usize(x_403, 2);
+if (lean_is_exclusive(x_403)) {
+ lean_ctor_release(x_403, 0);
+ lean_ctor_release(x_403, 1);
+ x_643 = x_403;
+} else {
+ lean_dec_ref(x_403);
+ x_643 = lean_box(0);
+}
+x_644 = l_Lean_nameToExprAux___main___closed__1;
+x_645 = lean_string_dec_eq(x_641, x_644);
+lean_dec(x_641);
+if (x_645 == 0)
+{
+lean_object* x_646; lean_object* x_647; 
+lean_dec(x_643);
+lean_dec(x_640);
+lean_dec(x_639);
+lean_dec(x_638);
+lean_dec(x_637);
+lean_dec(x_636);
+lean_dec(x_635);
+lean_dec(x_634);
+lean_dec(x_3);
+x_646 = lean_box(0);
+x_647 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_647, 0, x_646);
+lean_ctor_set(x_647, 1, x_5);
+return x_647;
+}
+else
+{
+lean_object* x_648; uint8_t x_649; 
+x_648 = l_Lean_Syntax_formatStx___main___closed__5;
+x_649 = lean_string_dec_eq(x_639, x_648);
+lean_dec(x_639);
+if (x_649 == 0)
+{
+lean_object* x_650; lean_object* x_651; 
+lean_dec(x_643);
+lean_dec(x_640);
+lean_dec(x_638);
+lean_dec(x_637);
+lean_dec(x_636);
+lean_dec(x_635);
+lean_dec(x_634);
+lean_dec(x_3);
+x_650 = lean_box(0);
+x_651 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_651, 0, x_650);
+lean_ctor_set(x_651, 1, x_5);
+return x_651;
+}
+else
+{
+lean_object* x_652; uint8_t x_653; 
+x_652 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1;
+x_653 = lean_string_dec_eq(x_637, x_652);
+lean_dec(x_637);
+if (x_653 == 0)
+{
+lean_object* x_654; lean_object* x_655; 
+lean_dec(x_643);
+lean_dec(x_640);
+lean_dec(x_638);
+lean_dec(x_636);
+lean_dec(x_635);
+lean_dec(x_634);
+lean_dec(x_3);
+x_654 = lean_box(0);
+x_655 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_655, 0, x_654);
+lean_ctor_set(x_655, 1, x_5);
+return x_655;
+}
+else
+{
+lean_object* x_656; uint8_t x_657; 
+x_656 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_657 = lean_string_dec_eq(x_635, x_656);
+if (x_657 == 0)
+{
+lean_object* x_658; uint8_t x_659; 
+x_658 = l_Lean_Parser_Level_hole___elambda__1___rarg___closed__1;
+x_659 = lean_string_dec_eq(x_635, x_658);
+lean_dec(x_635);
+if (x_659 == 0)
+{
+lean_object* x_660; lean_object* x_661; 
+lean_dec(x_643);
+lean_dec(x_640);
+lean_dec(x_638);
+lean_dec(x_636);
+lean_dec(x_634);
+lean_dec(x_3);
+x_660 = lean_box(0);
+x_661 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_661, 0, x_660);
+lean_ctor_set(x_661, 1, x_5);
+return x_661;
+}
+else
+{
+lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; lean_object* x_671; lean_object* x_672; lean_object* x_673; 
+if (lean_is_scalar(x_643)) {
+ x_662 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_662 = x_643;
+}
+lean_ctor_set(x_662, 0, x_404);
+lean_ctor_set(x_662, 1, x_644);
+lean_ctor_set_usize(x_662, 2, x_642);
+if (lean_is_scalar(x_640)) {
+ x_663 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_663 = x_640;
+}
+lean_ctor_set(x_663, 0, x_662);
+lean_ctor_set(x_663, 1, x_648);
+lean_ctor_set_usize(x_663, 2, x_642);
+if (lean_is_scalar(x_638)) {
+ x_664 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_664 = x_638;
+}
+lean_ctor_set(x_664, 0, x_663);
+lean_ctor_set(x_664, 1, x_652);
+lean_ctor_set_usize(x_664, 2, x_642);
+if (lean_is_scalar(x_636)) {
+ x_665 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_665 = x_636;
+}
+lean_ctor_set(x_665, 0, x_664);
+lean_ctor_set(x_665, 1, x_658);
+lean_ctor_set_usize(x_665, 2, x_642);
+x_666 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_666, 0, x_665);
+lean_ctor_set(x_666, 1, x_634);
+x_667 = l___private_Init_Lean_Elab_Term_5__mkFreshAnonymousIdent(x_666, x_4, x_5);
+lean_dec(x_666);
+x_668 = lean_ctor_get(x_667, 0);
+lean_inc(x_668);
+x_669 = lean_ctor_get(x_667, 1);
+lean_inc(x_669);
+if (lean_is_exclusive(x_667)) {
+ lean_ctor_release(x_667, 0);
+ lean_ctor_release(x_667, 1);
+ x_670 = x_667;
+} else {
+ lean_dec_ref(x_667);
+ x_670 = lean_box(0);
+}
+x_671 = lean_array_push(x_3, x_668);
+x_672 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_672, 0, x_671);
+if (lean_is_scalar(x_670)) {
+ x_673 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_673 = x_670;
+}
+lean_ctor_set(x_673, 0, x_672);
+lean_ctor_set(x_673, 1, x_669);
+return x_673;
+}
+}
+else
+{
+lean_object* x_674; lean_object* x_675; lean_object* x_676; uint8_t x_677; 
+lean_dec(x_643);
+lean_dec(x_640);
+lean_dec(x_638);
+lean_dec(x_636);
+lean_dec(x_635);
+x_674 = lean_unsigned_to_nat(1u);
+x_675 = lean_box(0);
+x_676 = l_Array_getD___rarg(x_634, x_674, x_675);
+x_677 = l_Lean_Syntax_isNone(x_676);
+lean_dec(x_676);
+if (x_677 == 0)
+{
+lean_object* x_678; lean_object* x_679; 
+lean_dec(x_634);
+lean_dec(x_3);
+x_678 = lean_box(0);
+x_679 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_679, 0, x_678);
+lean_ctor_set(x_679, 1, x_5);
+return x_679;
+}
+else
+{
+lean_object* x_680; lean_object* x_681; lean_object* x_682; lean_object* x_683; lean_object* x_684; 
+x_680 = lean_unsigned_to_nat(0u);
+x_681 = l_Array_getD___rarg(x_634, x_680, x_675);
+lean_dec(x_634);
+x_682 = lean_array_push(x_3, x_681);
+x_683 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_683, 0, x_682);
+x_684 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_684, 0, x_683);
+lean_ctor_set(x_684, 1, x_5);
+return x_684;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_685; lean_object* x_686; 
+lean_dec(x_404);
+lean_dec(x_403);
+lean_dec(x_402);
+lean_dec(x_401);
+lean_dec(x_400);
 lean_dec(x_3);
 lean_dec(x_2);
-x_109 = lean_box(0);
-x_110 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_110, 0, x_109);
-lean_ctor_set(x_110, 1, x_5);
-return x_110;
+x_685 = lean_box(0);
+x_686 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_686, 0, x_685);
+lean_ctor_set(x_686, 1, x_5);
+return x_686;
 }
 }
 else
 {
-lean_object* x_111; lean_object* x_112; 
-lean_dec(x_75);
-lean_dec(x_74);
-lean_dec(x_73);
-lean_dec(x_72);
+lean_object* x_687; lean_object* x_688; 
+lean_dec(x_403);
+lean_dec(x_402);
+lean_dec(x_401);
+lean_dec(x_400);
 lean_dec(x_3);
 lean_dec(x_2);
-x_111 = lean_box(0);
-x_112 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_112, 0, x_111);
-lean_ctor_set(x_112, 1, x_5);
-return x_112;
+x_687 = lean_box(0);
+x_688 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_688, 0, x_687);
+lean_ctor_set(x_688, 1, x_5);
+return x_688;
 }
 }
 else
 {
-lean_object* x_113; lean_object* x_114; 
-lean_dec(x_74);
-lean_dec(x_73);
-lean_dec(x_72);
+lean_object* x_689; lean_object* x_690; 
+lean_dec(x_402);
+lean_dec(x_401);
+lean_dec(x_400);
 lean_dec(x_3);
 lean_dec(x_2);
-x_113 = lean_box(0);
-x_114 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_114, 0, x_113);
-lean_ctor_set(x_114, 1, x_5);
-return x_114;
+x_689 = lean_box(0);
+x_690 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_690, 0, x_689);
+lean_ctor_set(x_690, 1, x_5);
+return x_690;
 }
 }
 else
 {
-lean_object* x_115; lean_object* x_116; 
-lean_dec(x_73);
-lean_dec(x_72);
+lean_object* x_691; lean_object* x_692; 
+lean_dec(x_401);
+lean_dec(x_400);
 lean_dec(x_3);
 lean_dec(x_2);
-x_115 = lean_box(0);
-x_116 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_116, 0, x_115);
-lean_ctor_set(x_116, 1, x_5);
-return x_116;
+x_691 = lean_box(0);
+x_692 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_692, 0, x_691);
+lean_ctor_set(x_692, 1, x_5);
+return x_692;
 }
 }
 else
 {
-lean_object* x_117; lean_object* x_118; 
-lean_dec(x_72);
+lean_object* x_693; lean_object* x_694; 
+lean_dec(x_400);
 lean_dec(x_3);
 lean_dec(x_2);
-x_117 = lean_box(0);
-x_118 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_118, 0, x_117);
-lean_ctor_set(x_118, 1, x_5);
-return x_118;
+x_693 = lean_box(0);
+x_694 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_694, 0, x_693);
+lean_ctor_set(x_694, 1, x_5);
+return x_694;
 }
 }
 else
 {
-lean_object* x_119; lean_object* x_120; 
+lean_object* x_695; lean_object* x_696; 
 lean_dec(x_3);
 lean_dec(x_2);
-x_119 = lean_box(0);
-x_120 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_120, 0, x_119);
-lean_ctor_set(x_120, 1, x_5);
-return x_120;
+x_695 = lean_box(0);
+x_696 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_696, 0, x_695);
+lean_ctor_set(x_696, 1, x_5);
+return x_696;
 }
 }
 }
@@ -34550,41 +37217,89 @@ return x_3;
 lean_object* l_Lean_Elab_Term_elabParen(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
-x_5 = lean_ctor_get(x_1, 1);
-lean_inc(x_5);
-x_6 = l_Lean_stxInh;
-x_7 = lean_unsigned_to_nat(1u);
-x_8 = lean_array_get(x_6, x_5, x_7);
-lean_dec(x_5);
-x_9 = l_Lean_Syntax_isNone(x_8);
-if (x_9 == 0)
+lean_object* x_5; uint8_t x_6; 
+x_5 = l_Lean_Parser_Term_paren___elambda__1___closed__1;
+x_6 = l_Lean_Syntax_isOfKind(x_1, x_5);
+if (x_6 == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_10 = lean_unsigned_to_nat(0u);
-x_11 = l_Lean_Syntax_getArg(x_8, x_10);
-x_12 = l_Lean_Syntax_getArg(x_8, x_7);
-lean_dec(x_8);
-x_13 = l_Lean_Syntax_isNone(x_12);
-if (x_13 == 0)
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_2);
+x_7 = l_Lean_Elab_Term_elabParen___closed__3;
+x_8 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_7, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_14 = l_Lean_Syntax_getArg(x_12, x_10);
-lean_dec(x_12);
-x_15 = l_Lean_Syntax_getKind(x_14);
-x_16 = l_Lean_Parser_Term_typeAscription___elambda__1___rarg___closed__2;
-x_17 = lean_name_eq(x_15, x_16);
-if (x_17 == 0)
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_9 = l_Lean_Syntax_getArgs(x_1);
+x_10 = lean_array_get_size(x_9);
+lean_dec(x_9);
+x_11 = lean_unsigned_to_nat(3u);
+x_12 = lean_nat_dec_eq(x_10, x_11);
+lean_dec(x_10);
+if (x_12 == 0)
 {
-lean_object* x_18; uint8_t x_19; 
-x_18 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
-x_19 = lean_name_eq(x_15, x_18);
-lean_dec(x_15);
-if (x_19 == 0)
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_2);
+x_13 = l_Lean_Elab_Term_elabParen___closed__3;
+x_14 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_13, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_14;
+}
+else
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; 
+x_15 = lean_unsigned_to_nat(1u);
+x_16 = l_Lean_Syntax_getArg(x_1, x_15);
+x_17 = l_Lean_nullKind___closed__2;
+x_18 = l_Lean_Syntax_isOfKind(x_16, x_17);
+if (x_18 == 0)
+{
+lean_object* x_118; 
+x_118 = lean_box(0);
+x_19 = x_118;
+goto block_117;
+}
+else
+{
+lean_object* x_119; lean_object* x_120; lean_object* x_121; uint8_t x_122; 
+x_119 = l_Lean_Syntax_getArgs(x_16);
+x_120 = lean_array_get_size(x_119);
+lean_dec(x_119);
+x_121 = lean_unsigned_to_nat(0u);
+x_122 = lean_nat_dec_eq(x_120, x_121);
+lean_dec(x_120);
+if (x_122 == 0)
+{
+lean_object* x_123; 
+x_123 = lean_box(0);
+x_19 = x_123;
+goto block_117;
+}
+else
+{
+lean_object* x_124; lean_object* x_125; 
+lean_dec(x_16);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_124 = l_Lean_Elab_Term_elabParen___closed__6;
+x_125 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_125, 0, x_124);
+lean_ctor_set(x_125, 1, x_4);
+return x_125;
+}
+}
+block_117:
+{
+lean_dec(x_19);
+if (x_18 == 0)
 {
 lean_object* x_20; lean_object* x_21; 
-lean_dec(x_14);
-lean_dec(x_11);
+lean_dec(x_16);
 lean_dec(x_2);
 x_20 = l_Lean_Elab_Term_elabParen___closed__3;
 x_21 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_20, x_3, x_4);
@@ -34594,222 +37309,370 @@ return x_21;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; 
-x_22 = l_Lean_Syntax_getArg(x_14, x_7);
-lean_dec(x_14);
-x_23 = l_Lean_mkOptionalNode___closed__1;
-x_24 = lean_array_push(x_23, x_11);
-x_25 = l_Lean_Syntax_getArgs(x_22);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_22 = l_Lean_Syntax_getArgs(x_16);
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-x_26 = lean_unsigned_to_nat(2u);
-x_27 = l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_foldSepRevArgsM___spec__1(x_26, x_25, x_10, x_24);
-lean_dec(x_25);
-x_28 = l_Lean_Elab_Term_mkPairs(x_27, x_3, x_4);
-lean_dec(x_27);
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_28, 1);
-lean_inc(x_30);
-lean_dec(x_28);
-x_31 = !lean_is_exclusive(x_3);
+x_24 = lean_unsigned_to_nat(2u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_16);
+lean_dec(x_2);
+x_26 = l_Lean_Elab_Term_elabParen___closed__3;
+x_27 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_26, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; 
+x_28 = lean_unsigned_to_nat(0u);
+x_29 = l_Lean_Syntax_getArg(x_16, x_28);
+x_30 = l_Lean_Syntax_getArg(x_16, x_15);
+lean_dec(x_16);
+x_31 = l_Lean_Syntax_isOfKind(x_30, x_17);
 if (x_31 == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_3, 7);
-x_33 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_33, 0, x_1);
-lean_ctor_set(x_33, 1, x_32);
-lean_ctor_set(x_3, 7, x_33);
-x_34 = l_Lean_Elab_Term_elabTerm(x_29, x_2, x_3, x_30);
-return x_34;
+lean_object* x_42; 
+x_42 = lean_box(0);
+x_32 = x_42;
+goto block_41;
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_35 = lean_ctor_get(x_3, 0);
-x_36 = lean_ctor_get(x_3, 1);
-x_37 = lean_ctor_get(x_3, 2);
-x_38 = lean_ctor_get(x_3, 3);
-x_39 = lean_ctor_get(x_3, 4);
-x_40 = lean_ctor_get(x_3, 5);
-x_41 = lean_ctor_get(x_3, 6);
-x_42 = lean_ctor_get(x_3, 7);
-x_43 = lean_ctor_get(x_3, 8);
-x_44 = lean_ctor_get_uint8(x_3, sizeof(void*)*9);
-lean_inc(x_43);
-lean_inc(x_42);
-lean_inc(x_41);
-lean_inc(x_40);
-lean_inc(x_39);
-lean_inc(x_38);
-lean_inc(x_37);
-lean_inc(x_36);
-lean_inc(x_35);
-lean_dec(x_3);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_1);
-lean_ctor_set(x_45, 1, x_42);
-x_46 = lean_alloc_ctor(0, 9, 1);
-lean_ctor_set(x_46, 0, x_35);
-lean_ctor_set(x_46, 1, x_36);
-lean_ctor_set(x_46, 2, x_37);
-lean_ctor_set(x_46, 3, x_38);
-lean_ctor_set(x_46, 4, x_39);
-lean_ctor_set(x_46, 5, x_40);
-lean_ctor_set(x_46, 6, x_41);
-lean_ctor_set(x_46, 7, x_45);
-lean_ctor_set(x_46, 8, x_43);
-lean_ctor_set_uint8(x_46, sizeof(void*)*9, x_44);
-x_47 = l_Lean_Elab_Term_elabTerm(x_29, x_2, x_46, x_30);
-return x_47;
-}
-}
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = l_Lean_Syntax_getArgs(x_30);
+x_44 = lean_array_get_size(x_43);
+lean_dec(x_43);
+x_45 = lean_nat_dec_eq(x_44, x_15);
+lean_dec(x_44);
+if (x_45 == 0)
+{
+lean_object* x_46; 
+x_46 = lean_box(0);
+x_32 = x_46;
+goto block_41;
 }
 else
 {
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_15);
-x_48 = l_Lean_Syntax_getArg(x_14, x_7);
-lean_dec(x_14);
-lean_inc(x_3);
-x_49 = l_Lean_Elab_Term_elabType(x_48, x_3, x_4);
-if (lean_obj_tag(x_49) == 0)
+lean_object* x_47; lean_object* x_48; lean_object* x_86; uint8_t x_87; 
+x_47 = l_Lean_Syntax_getArg(x_30, x_28);
+lean_dec(x_30);
+x_86 = l_Lean_Parser_Term_typeAscription___elambda__1___rarg___closed__2;
+x_87 = l_Lean_Syntax_isOfKind(x_47, x_86);
+if (x_87 == 0)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_49, 1);
-lean_inc(x_51);
-lean_dec(x_49);
-lean_inc(x_3);
-x_52 = l_Lean_Elab_Term_elabCDot(x_11, x_2, x_3, x_51);
-if (lean_obj_tag(x_52) == 0)
+lean_object* x_88; 
+x_88 = lean_box(0);
+x_48 = x_88;
+goto block_85;
+}
+else
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_53 = lean_ctor_get(x_52, 0);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_52, 1);
-lean_inc(x_54);
-lean_dec(x_52);
-lean_inc(x_3);
-lean_inc(x_53);
-x_55 = l_Lean_Elab_Term_inferType(x_1, x_53, x_3, x_54);
-if (lean_obj_tag(x_55) == 0)
+lean_object* x_89; lean_object* x_90; uint8_t x_91; 
+x_89 = l_Lean_Syntax_getArgs(x_47);
+x_90 = lean_array_get_size(x_89);
+lean_dec(x_89);
+x_91 = lean_nat_dec_eq(x_90, x_24);
+lean_dec(x_90);
+if (x_91 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 1);
-lean_inc(x_57);
-lean_dec(x_55);
-x_58 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_58, 0, x_50);
-x_59 = l_Lean_Elab_Term_ensureHasType(x_1, x_58, x_56, x_53, x_3, x_57);
+lean_object* x_92; 
+x_92 = lean_box(0);
+x_48 = x_92;
+goto block_85;
+}
+else
+{
+lean_object* x_93; lean_object* x_94; 
+x_93 = l_Lean_Syntax_getArg(x_47, x_15);
+lean_dec(x_47);
+lean_inc(x_3);
+x_94 = l_Lean_Elab_Term_elabType(x_93, x_3, x_4);
+if (lean_obj_tag(x_94) == 0)
+{
+lean_object* x_95; lean_object* x_96; lean_object* x_97; 
+x_95 = lean_ctor_get(x_94, 0);
+lean_inc(x_95);
+x_96 = lean_ctor_get(x_94, 1);
+lean_inc(x_96);
+lean_dec(x_94);
+lean_inc(x_3);
+x_97 = l_Lean_Elab_Term_elabCDot(x_29, x_2, x_3, x_96);
+if (lean_obj_tag(x_97) == 0)
+{
+lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_98 = lean_ctor_get(x_97, 0);
+lean_inc(x_98);
+x_99 = lean_ctor_get(x_97, 1);
+lean_inc(x_99);
+lean_dec(x_97);
+lean_inc(x_3);
+lean_inc(x_98);
+x_100 = l_Lean_Elab_Term_inferType(x_1, x_98, x_3, x_99);
+if (lean_obj_tag(x_100) == 0)
+{
+lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+x_101 = lean_ctor_get(x_100, 0);
+lean_inc(x_101);
+x_102 = lean_ctor_get(x_100, 1);
+lean_inc(x_102);
+lean_dec(x_100);
+x_103 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_103, 0, x_95);
+x_104 = l_Lean_Elab_Term_ensureHasType(x_1, x_103, x_101, x_98, x_3, x_102);
 lean_dec(x_1);
-return x_59;
+return x_104;
 }
 else
 {
-uint8_t x_60; 
-lean_dec(x_53);
-lean_dec(x_50);
+uint8_t x_105; 
+lean_dec(x_98);
+lean_dec(x_95);
 lean_dec(x_3);
 lean_dec(x_1);
-x_60 = !lean_is_exclusive(x_55);
-if (x_60 == 0)
+x_105 = !lean_is_exclusive(x_100);
+if (x_105 == 0)
 {
-return x_55;
+return x_100;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_55, 0);
-x_62 = lean_ctor_get(x_55, 1);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_55);
-x_63 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_63, 0, x_61);
-lean_ctor_set(x_63, 1, x_62);
-return x_63;
+lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+x_106 = lean_ctor_get(x_100, 0);
+x_107 = lean_ctor_get(x_100, 1);
+lean_inc(x_107);
+lean_inc(x_106);
+lean_dec(x_100);
+x_108 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_108, 0, x_106);
+lean_ctor_set(x_108, 1, x_107);
+return x_108;
 }
 }
 }
 else
 {
-uint8_t x_64; 
-lean_dec(x_50);
+uint8_t x_109; 
+lean_dec(x_95);
 lean_dec(x_3);
 lean_dec(x_1);
-x_64 = !lean_is_exclusive(x_52);
-if (x_64 == 0)
+x_109 = !lean_is_exclusive(x_97);
+if (x_109 == 0)
 {
+return x_97;
+}
+else
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+x_110 = lean_ctor_get(x_97, 0);
+x_111 = lean_ctor_get(x_97, 1);
+lean_inc(x_111);
+lean_inc(x_110);
+lean_dec(x_97);
+x_112 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_112, 0, x_110);
+lean_ctor_set(x_112, 1, x_111);
+return x_112;
+}
+}
+}
+else
+{
+uint8_t x_113; 
+lean_dec(x_29);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_113 = !lean_is_exclusive(x_94);
+if (x_113 == 0)
+{
+return x_94;
+}
+else
+{
+lean_object* x_114; lean_object* x_115; lean_object* x_116; 
+x_114 = lean_ctor_get(x_94, 0);
+x_115 = lean_ctor_get(x_94, 1);
+lean_inc(x_115);
+lean_inc(x_114);
+lean_dec(x_94);
+x_116 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_116, 0, x_114);
+lean_ctor_set(x_116, 1, x_115);
+return x_116;
+}
+}
+}
+}
+block_85:
+{
+lean_object* x_49; uint8_t x_50; 
+lean_dec(x_48);
+x_49 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
+x_50 = l_Lean_Syntax_isOfKind(x_47, x_49);
+if (x_50 == 0)
+{
+lean_object* x_51; lean_object* x_52; 
+lean_dec(x_47);
+lean_dec(x_29);
+lean_dec(x_2);
+x_51 = l_Lean_Elab_Term_elabParen___closed__3;
+x_52 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_51, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
 return x_52;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_52, 0);
-x_66 = lean_ctor_get(x_52, 1);
-lean_inc(x_66);
-lean_inc(x_65);
-lean_dec(x_52);
-x_67 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_67, 0, x_65);
-lean_ctor_set(x_67, 1, x_66);
-return x_67;
-}
-}
+lean_object* x_53; lean_object* x_54; uint8_t x_55; 
+x_53 = l_Lean_Syntax_getArgs(x_47);
+x_54 = lean_array_get_size(x_53);
+lean_dec(x_53);
+x_55 = lean_nat_dec_eq(x_54, x_24);
+lean_dec(x_54);
+if (x_55 == 0)
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_47);
+lean_dec(x_29);
+lean_dec(x_2);
+x_56 = l_Lean_Elab_Term_elabParen___closed__3;
+x_57 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_56, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_57;
 }
 else
 {
-uint8_t x_68; 
-lean_dec(x_11);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_68 = !lean_is_exclusive(x_49);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_58 = l_Lean_Syntax_getArg(x_47, x_15);
+lean_dec(x_47);
+x_59 = l_Lean_Syntax_getArgs(x_58);
+lean_dec(x_58);
+x_60 = l_Lean_mkOptionalNode___closed__1;
+x_61 = lean_array_push(x_60, x_29);
+x_62 = l_Array_empty___closed__1;
+x_63 = l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_foldSepRevArgsM___spec__1(x_24, x_59, x_28, x_62);
+lean_dec(x_59);
+x_64 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_63, x_63, x_28, x_61);
+lean_dec(x_63);
+x_65 = l_Lean_Elab_Term_mkPairs(x_64, x_3, x_4);
+lean_dec(x_64);
+x_66 = lean_ctor_get(x_65, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_65, 1);
+lean_inc(x_67);
+lean_dec(x_65);
+x_68 = !lean_is_exclusive(x_3);
 if (x_68 == 0)
 {
-return x_49;
-}
-else
-{
 lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_69 = lean_ctor_get(x_49, 0);
-x_70 = lean_ctor_get(x_49, 1);
-lean_inc(x_70);
-lean_inc(x_69);
-lean_dec(x_49);
-x_71 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_71, 0, x_69);
-lean_ctor_set(x_71, 1, x_70);
+x_69 = lean_ctor_get(x_3, 7);
+x_70 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_70, 0, x_1);
+lean_ctor_set(x_70, 1, x_69);
+lean_ctor_set(x_3, 7, x_70);
+x_71 = l_Lean_Elab_Term_elabTerm(x_66, x_2, x_3, x_67);
 return x_71;
 }
-}
-}
-}
 else
 {
-lean_object* x_72; 
-lean_dec(x_12);
-lean_dec(x_1);
-x_72 = l_Lean_Elab_Term_elabCDot(x_11, x_2, x_3, x_4);
-return x_72;
-}
-}
-else
-{
-lean_object* x_73; lean_object* x_74; 
-lean_dec(x_8);
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+x_72 = lean_ctor_get(x_3, 0);
+x_73 = lean_ctor_get(x_3, 1);
+x_74 = lean_ctor_get(x_3, 2);
+x_75 = lean_ctor_get(x_3, 3);
+x_76 = lean_ctor_get(x_3, 4);
+x_77 = lean_ctor_get(x_3, 5);
+x_78 = lean_ctor_get(x_3, 6);
+x_79 = lean_ctor_get(x_3, 7);
+x_80 = lean_ctor_get(x_3, 8);
+x_81 = lean_ctor_get_uint8(x_3, sizeof(void*)*9);
+lean_inc(x_80);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_inc(x_77);
+lean_inc(x_76);
+lean_inc(x_75);
+lean_inc(x_74);
+lean_inc(x_73);
+lean_inc(x_72);
 lean_dec(x_3);
+x_82 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_82, 0, x_1);
+lean_ctor_set(x_82, 1, x_79);
+x_83 = lean_alloc_ctor(0, 9, 1);
+lean_ctor_set(x_83, 0, x_72);
+lean_ctor_set(x_83, 1, x_73);
+lean_ctor_set(x_83, 2, x_74);
+lean_ctor_set(x_83, 3, x_75);
+lean_ctor_set(x_83, 4, x_76);
+lean_ctor_set(x_83, 5, x_77);
+lean_ctor_set(x_83, 6, x_78);
+lean_ctor_set(x_83, 7, x_82);
+lean_ctor_set(x_83, 8, x_80);
+lean_ctor_set_uint8(x_83, sizeof(void*)*9, x_81);
+x_84 = l_Lean_Elab_Term_elabTerm(x_66, x_2, x_83, x_67);
+return x_84;
+}
+}
+}
+}
+}
+}
+block_41:
+{
+lean_dec(x_32);
+if (x_31 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+lean_dec(x_30);
+lean_dec(x_29);
 lean_dec(x_2);
+x_33 = l_Lean_Elab_Term_elabParen___closed__3;
+x_34 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_33, x_3, x_4);
+lean_dec(x_3);
 lean_dec(x_1);
-x_73 = l_Lean_Elab_Term_elabParen___closed__6;
-x_74 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_74, 0, x_73);
-lean_ctor_set(x_74, 1, x_4);
-return x_74;
+return x_34;
+}
+else
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = l_Lean_Syntax_getArgs(x_30);
+lean_dec(x_30);
+x_36 = lean_array_get_size(x_35);
+lean_dec(x_35);
+x_37 = lean_nat_dec_eq(x_36, x_28);
+lean_dec(x_36);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_29);
+lean_dec(x_2);
+x_38 = l_Lean_Elab_Term_elabParen___closed__3;
+x_39 = l_Lean_Elab_throwError___at_Lean_Elab_Term_elabTerm___spec__1(x_1, x_38, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_39;
+}
+else
+{
+lean_object* x_40; 
+lean_dec(x_1);
+x_40 = l_Lean_Elab_Term_elabCDot(x_29, x_2, x_3, x_4);
+return x_40;
+}
+}
+}
+}
+}
+}
+}
 }
 }
 }
diff --git a/stage0/stdlib/Init/Lean/Parser/Parser.c b/stage0/stdlib/Init/Lean/Parser/Parser.c
index bd8ee3b2cd..58e8541e94 100644
--- a/stage0/stdlib/Init/Lean/Parser/Parser.c
+++ b/stage0/stdlib/Init/Lean/Parser/Parser.c
@@ -79,6 +79,7 @@ lean_object* l_Lean_Parser_checkLeadingFn(lean_object*, lean_object*, lean_objec
 lean_object* l_Lean_Parser_strAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_uget(lean_object*, size_t);
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1(lean_object*);
 lean_object* l_Lean_Syntax_foldArgsAuxM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_rawFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__1;
@@ -102,6 +103,7 @@ lean_object* l_Lean_Parser_symbolOrIdent___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_charLit(uint8_t);
 lean_object* l_Lean_Parser_hexNumberFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_trailingLoop___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldSepBy___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_1__expectedToString___main(lean_object*);
 lean_object* l_Lean_Parser_longestMatchFn(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserAttribute_inhabited___closed__3;
@@ -119,6 +121,7 @@ lean_object* l_Lean_Parser_ParserState_stackSize___boxed(lean_object*);
 lean_object* l_Lean_Parser_octalNumberFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_identFnAux___main___spec__4___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hexNumberFn(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldSepBy___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLitFnAux(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_6__updateCache(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_next(lean_object*, lean_object*, lean_object*);
@@ -162,6 +165,7 @@ lean_object* l_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__5(lean_obj
 lean_object* l_Lean_Parser_symbolNoWsFn___closed__1;
 uint8_t l_Lean_isIdBeginEscape(uint32_t);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__3;
+lean_object* l_Array_foldSepByM(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtension_Inhabited___rarg___lambda__1(lean_object*);
 lean_object* l_Lean_Parser_orelseFn(uint8_t);
 lean_object* l_Lean_Parser_ParserAttribute_runParser(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -304,6 +308,7 @@ lean_object* l_Lean_Parser_takeWhileFn___boxed(lean_object*, lean_object*, lean_
 lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_addBuiltinLeadingParser___closed__1;
 lean_object* l_Lean_Parser_ParserState_setPos(lean_object*, lean_object*);
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedSymbol___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_mkTokenAndFixPos___closed__1;
 lean_object* l_Lean_Parser_strLitFn___boxed(lean_object*, lean_object*);
@@ -377,6 +382,7 @@ lean_object* l_Lean_Parser_sepBy(uint8_t, lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Syntax_foldArgsM(lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_insertToken___closed__2;
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_insertToken___closed__1;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Parser_registerParserAttribute___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_trailingLoop___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -572,6 +578,7 @@ lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_forSepArgsM___sp
 lean_object* l_Lean_Parser_symbolNoWs(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hexDigitFn___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mergeErrors___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldSepBy(lean_object*);
 lean_object* l_Lean_Parser_trailingNode(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseInfo___elambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedCharFn___boxed(lean_object*, lean_object*);
@@ -592,6 +599,7 @@ lean_object* l_Lean_Parser_charLitFnAux___boxed(lean_object*, lean_object*, lean
 lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_forSepArgsM___spec__1(lean_object*);
 lean_object* l_Lean_Parser_tryFn___boxed(lean_object*);
 lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_foldArgs___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldSepByM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_Parser_addBuiltinTrailingParser___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkErrorAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdxFn___closed__1;
@@ -640,6 +648,7 @@ lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___r
 lean_object* l_Lean_nameToExprAux___main(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
+lean_object* l_Array_foldSepByM___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_addAndCompile(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(uint8_t, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(uint8_t, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
@@ -724,6 +733,7 @@ uint8_t l_Lean_Syntax_isNone(lean_object*);
 lean_object* l_Lean_Parser_strAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhile1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___rarg___closed__2;
+lean_object* l_Array_getEvenElems(lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___closed__1;
 lean_object* lean_io_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolOrIdentInfo___closed__1;
@@ -757,6 +767,7 @@ lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_foldSepRevArgsM_
 lean_object* l_Lean_Parser_currLbp(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhile1Fn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_initializing(lean_object*);
+lean_object* l_Array_getEvenElems___boxed(lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
 lean_object* l_Lean_Parser_sepByInfo___elambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolInfo___closed__1;
@@ -29669,6 +29680,125 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_Array_foldSepByM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_unsigned_to_nat(2u);
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = l_Lean_Syntax_foldArgsAuxM___main___rarg(x_1, x_5, x_2, x_3, x_6, x_4);
+return x_7;
+}
+}
+lean_object* l_Array_foldSepByM(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Array_foldSepByM___rarg), 4, 0);
+return x_3;
+}
+}
+lean_object* l_Array_foldSepByM___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_Array_foldSepByM(x_1, x_2);
+lean_dec(x_2);
+return x_3;
+}
+}
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; uint8_t x_7; 
+x_6 = lean_array_get_size(x_3);
+x_7 = lean_nat_dec_lt(x_4, x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+lean_dec(x_4);
+lean_dec(x_1);
+return x_5;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_8 = lean_array_fget(x_3, x_4);
+lean_inc(x_1);
+x_9 = lean_apply_2(x_1, x_8, x_5);
+x_10 = lean_nat_add(x_4, x_2);
+lean_dec(x_4);
+x_4 = x_10;
+x_5 = x_9;
+goto _start;
+}
+}
+}
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l_Array_foldSepBy___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_unsigned_to_nat(2u);
+x_5 = lean_unsigned_to_nat(0u);
+x_6 = l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg(x_2, x_4, x_1, x_5, x_3);
+return x_6;
+}
+}
+lean_object* l_Array_foldSepBy(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_foldSepBy___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_Syntax_foldArgsAuxM___main___at_Array_foldSepBy___spec__1___rarg(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_6;
+}
+}
+lean_object* l_Array_foldSepBy___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Array_foldSepBy___rarg(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_Array_getEvenElems(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_2 = lean_unsigned_to_nat(2u);
+x_3 = lean_unsigned_to_nat(0u);
+x_4 = l_Array_empty___closed__1;
+x_5 = l_Lean_Syntax_foldArgsAuxM___main___at_Lean_Syntax_foldSepRevArgsM___spec__1(x_2, x_1, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Array_getEvenElems___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Array_getEvenElems(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
 lean_object* initialize_Init_Lean_Data_Trie(lean_object*);
 lean_object* initialize_Init_Lean_Data_Position(lean_object*);
 lean_object* initialize_Init_Lean_Syntax(lean_object*);
diff --git a/stage0/stdlib/Init/Lean/Parser/Term.c b/stage0/stdlib/Init/Lean/Parser/Term.c
index a81e2c6321..53aca2b2cd 100644
--- a/stage0/stdlib/Init/Lean/Parser/Term.c
+++ b/stage0/stdlib/Init/Lean/Parser/Term.c
@@ -38,6 +38,7 @@ lean_object* l_Lean_Parser_Term_bnot___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Term_infixL___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_iff(lean_object*);
 lean_object* l_Lean_mkAppStx(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mkAntiquot___closed__15;
 lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_letEqns___elambda__1___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_suffices(lean_object*);
 lean_object* l_Lean_Parser_Term_arrayLit___closed__3;
@@ -108,6 +109,7 @@ lean_object* l_Lean_Parser_Term_matchAlt___closed__3;
 lean_object* l_Lean_Parser_Term_inaccessible___closed__2;
 lean_object* l_Lean_Parser_Term_structInst___closed__1;
 lean_object* l_Lean_Parser_Term_andM___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15;
 lean_object* l_Lean_Parser_Term_proj;
 lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_addParenHeuristic___closed__2;
@@ -121,6 +123,7 @@ lean_object* l_Lean_Parser_Term_doId___elambda__1___rarg(lean_object*, lean_obje
 lean_object* l_Lean_Parser_Term_band;
 lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___rarg___closed__2;
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_le;
 extern lean_object* l_Lean_nullKind;
 lean_object* l_Lean_Parser_Term_instBinder;
@@ -146,6 +149,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_explicit(lean_object*);
 lean_object* l_Lean_Parser_Term_type___closed__3;
 lean_object* l_Lean_Parser_Term_subtype___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_append(lean_object*);
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_haveAssign___closed__2;
 lean_object* l_Lean_Parser_Term_forall___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_prop___elambda__1___rarg___closed__3;
@@ -702,6 +706,7 @@ lean_object* l_Lean_Parser_Term_beq;
 lean_object* l_Lean_Parser_Term_prop___closed__2;
 lean_object* l_Lean_Parser_Term_let___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_bne;
+lean_object* l_Lean_Parser_Term_dollar___closed__5;
 lean_object* l_Lean_Parser_Term_letIdDecl___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_doSeq___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__7;
@@ -880,6 +885,7 @@ lean_object* l_Lean_Parser_Term_quotedName___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Term_append___closed__1;
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___rarg___closed__6;
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
+lean_object* l_Lean_Parser_Term_dollar___closed__7;
 lean_object* l_Lean_Parser_Term_id___closed__6;
 lean_object* l_Lean_Parser_Term_have___elambda__1___rarg___closed__9;
 lean_object* l_Lean_Parser_Term_map___elambda__1___closed__3;
@@ -915,6 +921,7 @@ lean_object* l_Lean_Parser_Term_arrayRef___elambda__1(lean_object*, lean_object*
 lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___rarg___closed__7;
 lean_object* l_Lean_Parser_Term_orM___elambda__1___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_anonymousCtor(lean_object*);
+lean_object* l_Lean_Parser_Term_mkAntiquot___closed__17;
 lean_object* l_Lean_Parser_Term_lt___closed__1;
 lean_object* l_Lean_Parser_Term_bindOp___closed__1;
 lean_object* l_Lean_Parser_Term_seq;
@@ -1154,6 +1161,7 @@ lean_object* l_Lean_Parser_Term_cdot___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___closed__1;
 lean_object* l_Lean_Parser_Term_fcomp___closed__1;
 lean_object* l_Lean_Parser_Term_str___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_Term_dollar___closed__6;
 lean_object* l_Lean_Parser_Term_match__syntax___closed__2;
 lean_object* l_Lean_Parser_Term_explicit___closed__3;
 lean_object* l_Lean_Parser_Term_binderType___closed__3;
@@ -1285,6 +1293,7 @@ lean_object* l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_sorry___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Term_prod___closed__1;
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_subst___closed__3;
 extern lean_object* l_Lean_Parser_Level_paren___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__5;
@@ -1434,6 +1443,7 @@ lean_object* l_Lean_Parser_Term_str___elambda__1___rarg(lean_object*, lean_objec
 lean_object* l_Lean_Parser_Term_append___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tupleTail___closed__2;
 lean_object* l_Lean_Parser_Term_structInstField___elambda__1___rarg___closed__2;
+lean_object* l_Lean_Parser_Term_dollar___closed__4;
 lean_object* l_Lean_Parser_Term_arrayRef___closed__1;
 lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_letEqns___elambda__1___spec__1___closed__1;
 lean_object* l_Lean_Parser_builtinTermParsingTable;
@@ -1638,6 +1648,7 @@ lean_object* l_Lean_Parser_Term_beq___closed__2;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__2;
 lean_object* l_Lean_Parser_Term_ne___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_paren___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__1;
 lean_object* l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__11;
 lean_object* l_Lean_Parser_Term_stxQuot___closed__1;
@@ -1653,6 +1664,7 @@ lean_object* l_Lean_Parser_Term_fcomp___closed__2;
 lean_object* l_Lean_Parser_Term_map___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___rarg___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_gt(lean_object*);
+lean_object* l_Lean_Parser_Term_mkAntiquot___closed__16;
 lean_object* l_Lean_Parser_Term_app___closed__2;
 lean_object* l_Lean_Parser_Term_explicit___closed__5;
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__5;
@@ -2284,7 +2296,7 @@ lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__5
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("%%");
+x_1 = lean_mk_string("$");
 return x_1;
 }
 }
@@ -2317,19 +2329,17 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__9() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Char_HasRepr___closed__1;
-x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__8;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = lean_mk_string("no space before");
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__9;
-x_2 = l_Char_HasRepr___closed__1;
+x_1 = l_Char_HasRepr___closed__1;
+x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__8;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -2338,15 +2348,25 @@ lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__1
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__10;
+x_2 = l_Char_HasRepr___closed__1;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__10;
+x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__11;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -2356,22 +2376,22 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12;
+x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13;
 x_2 = l_Char_HasRepr___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13;
+x_2 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
@@ -2381,227 +2401,244 @@ return x_3;
 lean_object* l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
 x_4 = lean_array_get_size(x_3);
 lean_dec(x_3);
-x_54 = lean_ctor_get(x_2, 1);
-lean_inc(x_54);
-lean_inc(x_1);
-x_55 = l_Lean_Parser_tokenFn(x_1, x_2);
-x_56 = lean_ctor_get(x_55, 3);
-lean_inc(x_56);
-if (lean_obj_tag(x_56) == 0)
-{
-lean_object* x_57; lean_object* x_58; 
-x_57 = lean_ctor_get(x_55, 0);
-lean_inc(x_57);
-x_58 = l_Array_back___at___private_Init_Lean_Parser_Parser_6__updateCache___spec__1(x_57);
-lean_dec(x_57);
-if (lean_obj_tag(x_58) == 2)
-{
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_58, 1);
+x_59 = lean_ctor_get(x_2, 1);
 lean_inc(x_59);
-lean_dec(x_58);
-x_60 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__6;
-x_61 = lean_string_dec_eq(x_59, x_60);
-lean_dec(x_59);
-if (x_61 == 0)
+lean_inc(x_1);
+x_60 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_61 = lean_ctor_get(x_60, 3);
+lean_inc(x_61);
+if (lean_obj_tag(x_61) == 0)
 {
 lean_object* x_62; lean_object* x_63; 
-x_62 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14;
-x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_54);
-x_5 = x_63;
-goto block_53;
+x_62 = lean_ctor_get(x_60, 0);
+lean_inc(x_62);
+x_63 = l_Array_back___at___private_Init_Lean_Parser_Parser_6__updateCache___spec__1(x_62);
+lean_dec(x_62);
+if (lean_obj_tag(x_63) == 2)
+{
+lean_object* x_64; lean_object* x_65; uint8_t x_66; 
+x_64 = lean_ctor_get(x_63, 1);
+lean_inc(x_64);
+lean_dec(x_63);
+x_65 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__6;
+x_66 = lean_string_dec_eq(x_64, x_65);
+lean_dec(x_64);
+if (x_66 == 0)
+{
+lean_object* x_67; lean_object* x_68; 
+x_67 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15;
+x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_67, x_59);
+x_5 = x_68;
+goto block_58;
 }
 else
 {
-lean_dec(x_54);
-x_5 = x_55;
-goto block_53;
+lean_dec(x_59);
+x_5 = x_60;
+goto block_58;
 }
 }
 else
 {
-lean_object* x_64; lean_object* x_65; 
-lean_dec(x_58);
-x_64 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14;
-x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_54);
-x_5 = x_65;
-goto block_53;
+lean_object* x_69; lean_object* x_70; 
+lean_dec(x_63);
+x_69 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15;
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_69, x_59);
+x_5 = x_70;
+goto block_58;
 }
 }
 else
 {
-lean_object* x_66; lean_object* x_67; 
-lean_dec(x_56);
-x_66 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14;
-x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_54);
-x_5 = x_67;
-goto block_53;
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_61);
+x_71 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15;
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_71, x_59);
+x_5 = x_72;
+goto block_58;
 }
-block_53:
+block_58:
 {
 lean_object* x_6; 
 x_6 = lean_ctor_get(x_5, 3);
 lean_inc(x_6);
 if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_7 = l_Lean_Parser_termParserAttribute;
-x_8 = l_Lean_Parser_appPrec;
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__9;
+x_8 = l_Lean_Parser_checkNoWsBeforeFn(x_7, x_1, x_5);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = l_Lean_Parser_termParserAttribute;
+x_11 = l_Lean_Parser_appPrec;
 lean_inc(x_1);
-x_9 = l_Lean_Parser_ParserAttribute_runParser(x_7, x_8, x_1, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+x_12 = l_Lean_Parser_ParserAttribute_runParser(x_10, x_11, x_1, x_8);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_11 = lean_ctor_get(x_9, 0);
-lean_inc(x_11);
-x_12 = lean_array_get_size(x_11);
-lean_dec(x_11);
-x_13 = l_Lean_nullKind;
-x_14 = l_Lean_Parser_ParserState_mkNode(x_9, x_13, x_12);
-x_15 = lean_ctor_get(x_14, 3);
-lean_inc(x_15);
-if (lean_obj_tag(x_15) == 0)
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_34; lean_object* x_35; 
-x_16 = lean_ctor_get(x_14, 0);
-lean_inc(x_16);
-x_17 = lean_array_get_size(x_16);
-lean_dec(x_16);
-x_18 = lean_ctor_get(x_14, 1);
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_14 = lean_ctor_get(x_12, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_nullKind;
+x_17 = l_Lean_Parser_ParserState_mkNode(x_12, x_16, x_15);
+x_18 = lean_ctor_get(x_17, 3);
 lean_inc(x_18);
-x_34 = l_Lean_Parser_tokenFn(x_1, x_14);
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_36; lean_object* x_37; 
-x_36 = lean_ctor_get(x_34, 0);
-lean_inc(x_36);
-x_37 = l_Array_back___at___private_Init_Lean_Parser_Parser_6__updateCache___spec__1(x_36);
-lean_dec(x_36);
-if (lean_obj_tag(x_37) == 2)
-{
-lean_object* x_38; lean_object* x_39; uint8_t x_40; 
-x_38 = lean_ctor_get(x_37, 1);
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_37; lean_object* x_38; 
+x_19 = lean_ctor_get(x_17, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_ctor_get(x_17, 1);
+lean_inc(x_21);
+x_37 = l_Lean_Parser_tokenFn(x_1, x_17);
+x_38 = lean_ctor_get(x_37, 3);
 lean_inc(x_38);
-lean_dec(x_37);
-x_39 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__8;
-x_40 = lean_string_dec_eq(x_38, x_39);
+if (lean_obj_tag(x_38) == 0)
+{
+lean_object* x_39; lean_object* x_40; 
+x_39 = lean_ctor_get(x_37, 0);
+lean_inc(x_39);
+x_40 = l_Array_back___at___private_Init_Lean_Parser_Parser_6__updateCache___spec__1(x_39);
+lean_dec(x_39);
+if (lean_obj_tag(x_40) == 2)
+{
+lean_object* x_41; lean_object* x_42; uint8_t x_43; 
+x_41 = lean_ctor_get(x_40, 1);
+lean_inc(x_41);
+lean_dec(x_40);
+x_42 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__8;
+x_43 = lean_string_dec_eq(x_41, x_42);
+lean_dec(x_41);
+if (x_43 == 0)
+{
+lean_object* x_44; lean_object* x_45; 
+x_44 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12;
+lean_inc(x_21);
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_21);
+x_22 = x_45;
+goto block_36;
+}
+else
+{
+x_22 = x_37;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; 
+lean_dec(x_40);
+x_46 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12;
+lean_inc(x_21);
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_21);
+x_22 = x_47;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; 
 lean_dec(x_38);
-if (x_40 == 0)
+x_48 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__12;
+lean_inc(x_21);
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_21);
+x_22 = x_49;
+goto block_36;
+}
+block_36:
 {
-lean_object* x_41; lean_object* x_42; 
-x_41 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__11;
-lean_inc(x_18);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_41, x_18);
-x_19 = x_42;
-goto block_33;
+lean_object* x_23; 
+x_23 = lean_ctor_get(x_22, 3);
+lean_inc(x_23);
+if (lean_obj_tag(x_23) == 0)
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_21);
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_16, x_20);
+x_25 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_4);
+return x_26;
 }
 else
 {
-x_19 = x_34;
-goto block_33;
+lean_object* x_27; uint8_t x_28; 
+lean_dec(x_23);
+x_27 = lean_ctor_get(x_22, 1);
+lean_inc(x_27);
+x_28 = lean_nat_dec_eq(x_27, x_21);
+lean_dec(x_27);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_21);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_16, x_20);
+x_30 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_4);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_32 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
+x_33 = l_Lean_Parser_ParserState_mkNode(x_32, x_16, x_20);
+x_34 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_4);
+return x_35;
+}
+}
 }
 }
 else
 {
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_37);
-x_43 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__11;
-lean_inc(x_18);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_43, x_18);
-x_19 = x_44;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; 
-lean_dec(x_35);
-x_45 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__11;
-lean_inc(x_18);
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_45, x_18);
-x_19 = x_46;
-goto block_33;
-}
-block_33:
-{
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_object* x_50; lean_object* x_51; 
 lean_dec(x_18);
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_13, x_17);
-x_22 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_4);
-return x_23;
-}
-else
-{
-lean_object* x_24; uint8_t x_25; 
-lean_dec(x_20);
-x_24 = lean_ctor_get(x_19, 1);
-lean_inc(x_24);
-x_25 = lean_nat_dec_eq(x_24, x_18);
-lean_dec(x_24);
-if (x_25 == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_dec(x_18);
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_13, x_17);
-x_27 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_4);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-x_30 = l_Lean_Parser_ParserState_mkNode(x_29, x_13, x_17);
-x_31 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_4);
-return x_32;
-}
-}
-}
-}
-else
-{
-lean_object* x_47; lean_object* x_48; 
-lean_dec(x_15);
 lean_dec(x_1);
-x_47 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_14, x_47, x_4);
-return x_48;
+x_50 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_17, x_50, x_4);
+return x_51;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; 
-lean_dec(x_10);
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_13);
 lean_dec(x_1);
-x_49 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_9, x_49, x_4);
-return x_50;
+x_52 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_12, x_52, x_4);
+return x_53;
 }
 }
 else
 {
-lean_object* x_51; lean_object* x_52; 
+lean_object* x_54; lean_object* x_55; 
+lean_dec(x_9);
+lean_dec(x_1);
+x_54 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_8, x_54, x_4);
+return x_55;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_51 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_5, x_51, x_4);
-return x_52;
+x_56 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_5, x_56, x_4);
+return x_57;
 }
 }
 }
@@ -2641,14 +2678,24 @@ return x_6;
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__1() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(1u);
+x_2 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__2() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__6;
-x_2 = l_Lean_Parser_Level_paren___closed__1;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__1;
 x_3 = l_Lean_Parser_symbolInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__2() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -2658,7 +2705,7 @@ lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -2668,7 +2715,7 @@ x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__4() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -2678,30 +2725,20 @@ lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__5() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___closed__3;
-x_2 = l_Lean_Parser_optionaInfo(x_1);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__6() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_epsilonInfo;
-x_2 = l_Lean_Parser_Term_mkAntiquot___closed__5;
-x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
-return x_3;
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_Term_mkAntiquot___closed__4;
+x_2 = l_Lean_Parser_optionaInfo(x_1);
+return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_1 = l_Lean_Parser_epsilonInfo;
 x_2 = l_Lean_Parser_Term_mkAntiquot___closed__6;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -2711,7 +2748,7 @@ lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___closed__1;
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
 x_2 = l_Lean_Parser_Term_mkAntiquot___closed__7;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -2721,43 +2758,73 @@ lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_1 = l_Lean_Parser_epsilonInfo;
 x_2 = l_Lean_Parser_Term_mkAntiquot___closed__8;
-x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__10() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_mkAntiquot___closed__2;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__9;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__11() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__10;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__12() {
+_start:
+{
 lean_object* x_1; 
 x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mkAntiquot___elambda__1___boxed), 1, 0);
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__11() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___closed__9;
-x_2 = l_Lean_Parser_Term_mkAntiquot___closed__10;
+x_1 = l_Lean_Parser_Term_mkAntiquot___closed__11;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__12;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__12() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_mkAntiquot___closed__4;
+x_1 = l_Lean_Parser_Term_mkAntiquot___closed__5;
 x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__13() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__15() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__9;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 1);
+lean_closure_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__16() {
 _start:
 {
 lean_object* x_1; 
@@ -2765,7 +2832,7 @@ x_1 = lean_mk_string("no space before '");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__14() {
+lean_object* _init_l_Lean_Parser_Term_mkAntiquot___closed__17() {
 _start:
 {
 lean_object* x_1; 
@@ -2779,17 +2846,17 @@ _start:
 if (lean_obj_tag(x_1) == 0)
 {
 lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_mkAntiquot___closed__11;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__13;
 return x_2;
 }
 else
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
 x_3 = lean_ctor_get(x_1, 0);
 x_4 = lean_box(0);
 x_5 = l___private_Init_Util_1__mkPanicMessage___closed__2;
 x_6 = lean_string_append(x_5, x_3);
-x_7 = l_Lean_Parser_Term_mkAntiquot___closed__13;
+x_7 = l_Lean_Parser_Term_mkAntiquot___closed__16;
 x_8 = lean_string_append(x_7, x_6);
 x_9 = l_Char_HasRepr___closed__1;
 x_10 = lean_string_append(x_8, x_9);
@@ -2806,32 +2873,37 @@ lean_closure_set(x_16, 0, x_10);
 x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
 lean_closure_set(x_17, 0, x_16);
 lean_closure_set(x_17, 1, x_13);
-x_18 = l_Lean_Parser_Term_mkAntiquot___closed__5;
+x_18 = l_Lean_Parser_Term_mkAntiquot___closed__6;
 x_19 = l_Lean_Parser_andthenInfo(x_15, x_18);
-x_20 = l_Lean_Parser_Term_mkAntiquot___closed__12;
+x_20 = l_Lean_Parser_Term_mkAntiquot___closed__14;
 x_21 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
 lean_closure_set(x_21, 0, x_17);
 lean_closure_set(x_21, 1, x_20);
 x_22 = l_Lean_Parser_Parser_inhabited___closed__1;
 x_23 = l_Lean_Parser_andthenInfo(x_22, x_19);
-x_24 = l_Lean_Parser_Term_mkAntiquot___closed__14;
+x_24 = l_Lean_Parser_Term_mkAntiquot___closed__17;
 x_25 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
 lean_closure_set(x_25, 0, x_24);
 lean_closure_set(x_25, 1, x_21);
-x_26 = l_Lean_Parser_Term_mkAntiquot___closed__1;
-x_27 = l_Lean_Parser_andthenInfo(x_26, x_23);
-x_28 = l_Lean_Parser_Term_mkAntiquot___closed__2;
-x_29 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_29, 0, x_28);
-lean_closure_set(x_29, 1, x_25);
-x_30 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
-x_31 = l_Lean_Parser_nodeInfo(x_30, x_27);
-x_32 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mkAntiquot___elambda__2), 4, 1);
-lean_closure_set(x_32, 0, x_29);
-x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_31);
-lean_ctor_set(x_33, 1, x_32);
-return x_33;
+x_26 = l_Lean_Parser_andthenInfo(x_14, x_23);
+x_27 = l_Lean_Parser_Term_mkAntiquot___closed__15;
+x_28 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+lean_closure_set(x_28, 0, x_27);
+lean_closure_set(x_28, 1, x_25);
+x_29 = l_Lean_Parser_Term_mkAntiquot___closed__2;
+x_30 = l_Lean_Parser_andthenInfo(x_29, x_26);
+x_31 = l_Lean_Parser_Term_mkAntiquot___closed__3;
+x_32 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+lean_closure_set(x_32, 0, x_31);
+lean_closure_set(x_32, 1, x_28);
+x_33 = l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__4;
+x_34 = l_Lean_Parser_nodeInfo(x_33, x_30);
+x_35 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mkAntiquot___elambda__2), 4, 1);
+lean_closure_set(x_35, 0, x_32);
+x_36 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_36, 0, x_34);
+lean_ctor_set(x_36, 1, x_35);
+return x_36;
 }
 }
 }
@@ -26423,56 +26495,256 @@ return x_1;
 lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__4() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_dollar___elambda__1___closed__3;
-x_2 = lean_unsigned_to_nat(1u);
-x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
+x_2 = l_String_trim(x_1);
+return x_2;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Char_HasRepr___closed__1;
+x_2 = l_Lean_Parser_Term_dollar___elambda__1___closed__4;
+x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_dollar___elambda__1___closed__5;
+x_2 = l_Char_HasRepr___closed__1;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__7() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Parser_Term_dollar___elambda__1___closed__6;
+x_3 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_3, 0, x_2);
+lean_ctor_set(x_3, 1, x_1);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__8() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("space expected");
+return x_1;
+}
+}
 lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_4 = l_Lean_Parser_Term_dollar___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_29; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_3, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_3, 3);
 lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_7 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_29 = l_Lean_Parser_ParserState_pushSyntax(x_3, x_1);
+if (lean_obj_tag(x_6) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+lean_inc(x_2);
+x_30 = l_Lean_Parser_tokenFn(x_2, x_29);
+x_31 = lean_ctor_get(x_30, 3);
+lean_inc(x_31);
+if (lean_obj_tag(x_31) == 0)
+{
+lean_object* x_32; lean_object* x_33; 
+x_32 = lean_ctor_get(x_30, 0);
+lean_inc(x_32);
+x_33 = l_Array_back___at___private_Init_Lean_Parser_Parser_6__updateCache___spec__1(x_32);
+lean_dec(x_32);
+if (lean_obj_tag(x_33) == 2)
+{
+lean_object* x_34; lean_object* x_35; uint8_t x_36; 
+x_34 = lean_ctor_get(x_33, 1);
+lean_inc(x_34);
+lean_dec(x_33);
+x_35 = l_Lean_Parser_Term_dollar___elambda__1___closed__4;
+x_36 = lean_string_dec_eq(x_34, x_35);
+lean_dec(x_34);
+if (x_36 == 0)
+{
+lean_object* x_37; lean_object* x_38; 
+x_37 = l_Lean_Parser_Term_dollar___elambda__1___closed__7;
+lean_inc(x_5);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_37, x_5);
+x_8 = x_38;
+goto block_28;
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+x_39 = l_Lean_Parser_Term_dollar___elambda__1___closed__8;
+x_40 = l_Lean_Parser_checkWsBeforeFn(x_39, x_2, x_30);
+x_8 = x_40;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; 
+lean_dec(x_33);
+x_41 = l_Lean_Parser_Term_dollar___elambda__1___closed__7;
+lean_inc(x_5);
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_41, x_5);
+x_8 = x_42;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; 
+lean_dec(x_31);
+x_43 = l_Lean_Parser_Term_dollar___elambda__1___closed__7;
+lean_inc(x_5);
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_43, x_5);
+x_8 = x_44;
+goto block_28;
+}
+}
+else
+{
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7);
-return x_10;
+x_8 = x_29;
+goto block_28;
+}
+block_28:
+{
+lean_object* x_9; 
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_5);
+x_10 = l_Lean_Parser_termParserAttribute;
+x_11 = lean_unsigned_to_nat(0u);
+x_12 = l_Lean_Parser_ParserAttribute_runParser(x_10, x_11, x_2, x_8);
+x_13 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7);
+return x_14;
+}
+else
+{
+uint8_t x_15; 
+lean_dec(x_2);
+x_15 = !lean_is_exclusive(x_8);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_16 = lean_ctor_get(x_8, 0);
+x_17 = lean_ctor_get(x_8, 3);
+lean_dec(x_17);
+x_18 = lean_ctor_get(x_8, 1);
+lean_dec(x_18);
+x_19 = l_Array_shrink___main___rarg(x_16, x_7);
+lean_ctor_set(x_8, 1, x_5);
+lean_ctor_set(x_8, 0, x_19);
+x_20 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkNode(x_8, x_20, x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_22 = lean_ctor_get(x_8, 0);
+x_23 = lean_ctor_get(x_8, 2);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_dec(x_8);
+x_24 = l_Array_shrink___main___rarg(x_22, x_7);
+x_25 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_5);
+lean_ctor_set(x_25, 2, x_23);
+lean_ctor_set(x_25, 3, x_9);
+x_26 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7);
+return x_27;
+}
+}
+}
 }
 }
 lean_object* _init_l_Lean_Parser_Term_dollar___closed__1() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_dollar___elambda__1___closed__4;
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
-x_4 = l_Lean_Parser_nodeInfo(x_3, x_2);
-return x_4;
+x_2 = l_Lean_Parser_Term_mkAntiquot___closed__1;
+x_3 = l_Lean_Parser_symbolInfo(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_dollar___closed__2() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_dollar___closed__1;
+x_2 = l_Lean_Parser_epsilonInfo;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_epsilonInfo;
+x_2 = l_Lean_Parser_Term_dollar___closed__2;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_dollar___closed__3;
+x_2 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+x_2 = l_Lean_Parser_Term_dollar___closed__4;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__6() {
+_start:
+{
 lean_object* x_1; 
 x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollar___elambda__1), 3, 0);
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_dollar___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_dollar___closed__1;
-x_2 = l_Lean_Parser_Term_dollar___closed__2;
+x_1 = l_Lean_Parser_Term_dollar___closed__5;
+x_2 = l_Lean_Parser_Term_dollar___closed__6;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -26483,7 +26755,7 @@ lean_object* _init_l_Lean_Parser_Term_dollar() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_dollar___closed__3;
+x_1 = l_Lean_Parser_Term_dollar___closed__7;
 return x_1;
 }
 }
@@ -30749,6 +31021,8 @@ l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13 = _init_l_Lean_Pa
 lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__13);
 l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14 = _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14();
 lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__14);
+l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15 = _init_l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15();
+lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___elambda__1___rarg___closed__15);
 l_Lean_Parser_Term_mkAntiquot___closed__1 = _init_l_Lean_Parser_Term_mkAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__1);
 l_Lean_Parser_Term_mkAntiquot___closed__2 = _init_l_Lean_Parser_Term_mkAntiquot___closed__2();
@@ -30777,6 +31051,12 @@ l_Lean_Parser_Term_mkAntiquot___closed__13 = _init_l_Lean_Parser_Term_mkAntiquot
 lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__13);
 l_Lean_Parser_Term_mkAntiquot___closed__14 = _init_l_Lean_Parser_Term_mkAntiquot___closed__14();
 lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__14);
+l_Lean_Parser_Term_mkAntiquot___closed__15 = _init_l_Lean_Parser_Term_mkAntiquot___closed__15();
+lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__15);
+l_Lean_Parser_Term_mkAntiquot___closed__16 = _init_l_Lean_Parser_Term_mkAntiquot___closed__16();
+lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__16);
+l_Lean_Parser_Term_mkAntiquot___closed__17 = _init_l_Lean_Parser_Term_mkAntiquot___closed__17();
+lean_mark_persistent(l_Lean_Parser_Term_mkAntiquot___closed__17);
 l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1 = _init_l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1);
 l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__2 = _init_l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__2();
@@ -32798,12 +33078,28 @@ l_Lean_Parser_Term_dollar___elambda__1___closed__3 = _init_l_Lean_Parser_Term_do
 lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__3);
 l_Lean_Parser_Term_dollar___elambda__1___closed__4 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__4);
+l_Lean_Parser_Term_dollar___elambda__1___closed__5 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__5();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__5);
+l_Lean_Parser_Term_dollar___elambda__1___closed__6 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__6();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__6);
+l_Lean_Parser_Term_dollar___elambda__1___closed__7 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__7();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__7);
+l_Lean_Parser_Term_dollar___elambda__1___closed__8 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__8();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__8);
 l_Lean_Parser_Term_dollar___closed__1 = _init_l_Lean_Parser_Term_dollar___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__1);
 l_Lean_Parser_Term_dollar___closed__2 = _init_l_Lean_Parser_Term_dollar___closed__2();
 lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__2);
 l_Lean_Parser_Term_dollar___closed__3 = _init_l_Lean_Parser_Term_dollar___closed__3();
 lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__3);
+l_Lean_Parser_Term_dollar___closed__4 = _init_l_Lean_Parser_Term_dollar___closed__4();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__4);
+l_Lean_Parser_Term_dollar___closed__5 = _init_l_Lean_Parser_Term_dollar___closed__5();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__5);
+l_Lean_Parser_Term_dollar___closed__6 = _init_l_Lean_Parser_Term_dollar___closed__6();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__6);
+l_Lean_Parser_Term_dollar___closed__7 = _init_l_Lean_Parser_Term_dollar___closed__7();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___closed__7);
 l_Lean_Parser_Term_dollar = _init_l_Lean_Parser_Term_dollar();
 lean_mark_persistent(l_Lean_Parser_Term_dollar);
 res = l___regBuiltinParser_Lean_Parser_Term_dollar(lean_io_mk_world());